There are a lot of good reasons to have a standalone native mobile app for your ethereum token/smart contract/DApp (Decentralized App):

  • Accessibility: Just a single tap away from the home screen means more frequent usage
  • Independence: You can provide custom user experience just for your users who sign in with the app specific private key. You control your own user experience and don’t have to depend on generic web browsers or generic wallet UI.
  • Optimized UX: Relying on generic wallets or generic DApp browsers means you delegate all the transaction-related UX to the browser. This means you can’t provide an…


Recently I sat down and looked into some features and previous design decisions that made Jasonette needlessly more confusing that it needed to be, and fixed them. Here are the three:

  1. No more “String only” policy
  2. No mandatory requirement for “head”
  3. No more confusing tab bar

1. No more “String ONLY” policy

Anyone who’s had to deal with Jasonette templates will appreciate this a lot. Previously, a lot of confusion and annoyance came from the fact that you had to turn everything into string before rendering.

For example, something like this would crash the app because the 12345 is a number:

{
"type": "label", "text": 12345…


How sandboxed views talk to each other in Jasonette

Jasonette takes security very seriously. The entire architecture was built on a sandbox model that took inspiration from web browsers and applied to mobile context.

Each view is completely sandboxed but they can communicate with other views through predefined protocols, resembling how microservices work.

In this post I will explain:

  1. How the sandbox model works in Jasonette
  2. How two views can communicate back and forth using $href and $ok action protocols.

How Sandbox Model Works in Jasonette

If a language encourages certain design patterns that are insecure, regardless of how secure the low level architecture is, we should consider the language insecure.

For example, the language…


A New Approach for Blending Web Engine into Native Apps

What if I told you the 7 lines of JSON above, colored in orange is all you need to turn a website into a mobile app? No need to rewrite your website using some framework API just to make it behave like a mobile app. Just bring your existing website as is, and blend it into a native app with a simple URL reference.

And what if, just by tweaking the JSON markup a bit, you can access all the native APIs, native UI components, as well as native view transitions out of the box?

Here’s what a minimal example…


Nowadays we see QR code everywhere. We see it on a billboard, we see it embedded in product packaging, we use it to share Bitcoin public key.

QR code is like a 2D version of barcode.

As a publisher, you can pack all kinds of data in it as an image, and as a consumer you can simply scan the QR code to extract whatever is stored in the code.


Jasonette lets you build cross platform native mobile apps simply by writing a JSON markup.

When you load your JSON markup URL from it, Jasonette “remote controls” all the built-in native Objective-C (iOS) and Java (Android) components/APIs, in realtime.

What if you could do the same, but in a web browser?

This is Jasonette-Web.

How it works

Here’s a simple comparison

  • Jasonette-iOS: JSON => Native iOS Components + Objective-C function calls
  • Jasonette-Android: JSON => Native Android Components + Java function calls
  • Jasonette-Web: JSON => HTML DOM

One notable difference:

  • Jasonette-iOS and Jasonette-Android let you express an entire app in JSON — that is…


The latest version of Jasonette supports a “Headerless view”, in other words a view without the header navigation bar at the top.

See below images for an example. Depending on whether you define $jason.body.header or not, the header part shows up or goes away completely.


Now you can inject JavaScript libraries into JSON templates.

Jasonette has a powerful client-side template engine built in, which uses the commonly used {{ }} notation. It looks like this:

{
"items": [{
"type": "image",
"url": "{{$jason.image}}"
}, {
"type": "label",
"text": "{{$jason.username}}"
}]
}

Aside from obvious templating features like #if, #each, etc., the template lets you even use full-fledged JavaScript expressions:

{
"items": [{
"type": "label",
"url": "Reversed Fullname"
}, {
"type": "label",
"text": "{{var sorted_posts = $jason.posts.sort(function(a,b){ return new Date(b.created_at) - new Date(a.created_at); }); return sorted_posts[0];}}"
}]
}

This has been very useful, but we can do better. Here are some of the problems:

  1. This can…


Build offline first apps with nothing but JSON.

Jasonette is an open source framework that makes it super easy to build iOS and Android native apps using just a single JSON markup.

It’s like building a website by writing HTML, but you’re building a native app instead, by writing JSON.

Whenever you open an app built with Jasonette, its JSON markup would load over HTTP and self-construct into a native app, in realtime. Basically the entire app logic exists on a remote server and gets streamed to your “app”.

What if we could load the app not just from a remote server, but directly from the device?

Introducing Jasonette Offline.

Not…


For the past few months, I’ve been working on a new way to build cross-platform, native iOS and Android apps called Jasonette.

It lets you describe an entire app with nothing but a single JSON markup.

If your app consists entirely of JSON, it can be treated like any other data. And it can be served remotely from the cloud on-demand.

The app logic no longer needs to be hardcoded on the device, and you can update it as much as you want just by updating your JSON on the server-side. …

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store