That will depend on what technique and GUI library you'll be using.
**_My understanding of this is extremely tenuous_**, but — just to help get the
ball rolling — here's a high-level outline of the various mobile software
development options and how they relate to Nim. I hope that someone more
knowledgeable will come along to fill in the gaps and correct me as needed...
* * *
**Android *N*DK (C/C++) Based Apps:**
* [nimx](https://github.com/yglukhov/nimx), the "cross-platform GUI framework
in Nim". "Nimx officially supports Linux, MacOS, Windows, Android, iOS,
Javascript (with Nim JS backend), and Asm.js (with Nim C backend and
Emscripten)." I think it uses Android's Java SDK (via jnim, see below) for just
a few things, and NDK / sdl2 for everything else. This option will limit you to
just the things supported by nimx, but this is **probably the easiest
approach** and you're not married to just Android.
* Using [sdl2](https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer)
directly. An example of this approach is "[NimES: NES Emulator in
Nim](https://github.com/def-/nimes)". This makes sense for things like games,
but you'd have to "reinvent the wheel" when it comes to drawing widgets.
* There's [Qt for
Android](http://forum.nim-lang.org///doc.qt.io/qt-5/android-support.html) and
there are Nim bindings for
[Qt5](https://github.com/philip-wernersbach/nim-qt5_qtsql) /
[qml](https://github.com/filcuc/nimqml), but I don't know if ever the twain
shall meet... (Disclaimer: being an [anti-GPL
zealot](http://forum.nim-lang.org///copyfree.org/standard/rejected), I am
highly biased against Qt.)
* * *
**Android SDK (Java) Based Apps:**
This would mean a bridge between Nim and Android's rich habitat of UI widgets,
libraries, and everything else offered by its Java SDK. If you go this route,
your app will lack nothing compared to Android apps written entirely in Java,
but it'll be married to just Android and would need an emulator to run on PC or
iOS. (See also: [a recent "nim4android" thread on this
forum](http://forum.nim-lang.org///forum.nim-lang.org/t/2613).)
* [jnim](https://github.com/vegansk/jnim) \- "Native language integration
with Java VM has never been easier!" claims this library - but it seems like a
cutting-edge effort, and you'll be blazing a new trail with Android bindings...
I can't find any examples of anyone using this in production just yet, but it
seems to be in active development. "The documentation is coming soon."
* * *
**Web-Based Apps:**
An important question to ask is whether your projects actually needs to be an
"app". It's amazing what can be accomplished inside the Web browser these days!
Technologies to research include: the latest HTML5 advances, IndexedDB, SSE,
and various in-browser front-end frameworks (ex. bootstrap). There are
different approaches to this (some very new), which involve Nim in varying
capacities and to varying degrees:
* **Client-Server App**: Nim can definitely be used for a highly scalable
server end of the app. The client end can be written in Nim and compiled to
JavaScript. Nim's [dom](http://forum.nim-lang.org///nim-lang.org/docs/dom.html)
module provides only very basic bare-bones functionality, but it's a start.
This
[XHR](https://github.com/yglukhov/async_http_request/blob/master/async_http_request.nim)
module proviles an example of the vision for creating Nim libraries that work
both in a native C program as well as an in-browser JS. And soon
[wasm](https://en.wikipedia.org/wiki/WebAssembly) will provide yet another
client-side option.
* **On-Phone-Server App**: This is a variation of a traditional client-server
model where part or all of the web server functionality runs as a native app on
the phone. You can easily build such Web server app on top of a Nim web
framework like [jester](https://github.com/dom96/jester). Simple Web servers
that don't use large databases can easily run even on my puny $30 phone - using
something like SQLite for storage, and generating an HTML5 UI with little or no
need for client-side JS. A local Web server can be accessed by pointing the
mobile Web browser to localhost:port, or via a minimal app that embeds Chrome
without the user knowing it. With the former approach, you can avoid all
Android-specific packaging overhead and just scp executable files to the phone
(I use
[SSHelper](https://play.google.com/store/apps/details?id=com.arachnoid.sshelper&hl=en)).
* **Serverless P2P App**: this is a fairly new idea in the JavaScript world
that does not yet connect to Nim, but it could. Technologies to research would
include the in-browser JS implementations of [IPFS](https://ipfs.io/),
[IPLD](https://github.com/ipld/js-ipld-dag-pb), and
[libp2p](https://github.com/ipfs/js-libp2p-ipfs-browser). It would be awesome
if Nim's JS target functionality evolved beyond just the current dom module and
connected to these technologies to allow serverless in-b
