As Gerry mentioned, it's already possible (and not difficult) to run a
Tcl interpreter on an Android device. You can do this through one of
Roy Keene's tclkits, prebuilt for arm. This is a long way off from
actually writing an Android app (i.e. something you'd see on the app
store) in Tcl and a Tk-like gui toolkit.
I've done most of the work necessary to get a native-compiled Tcl
interpreter to run from within an distributable Android package (.apk)
file, building on Roy Keene's work. This mostly involves making sure
that the process environment for a given .APK is set up in a way that
Tcl needs (a writeable TMPDIR, etc.).
If you wanted to talk about using Tcl to create fully-usable GUI
applications, there are basically two routes I think you could go,
either wrapping the Android native widgets in a Tk-like language, or
using the Android's canvas-like widget as a full-screen "blank slate"
and drawing your own widgets to that. Going the first route, you're
looking at a certain amount of effort to write a lot of wrapper code.
Going the second route, you're still looking at a lot of effort, and
then your applications will always "look funny" (i.e. not native).
Quick aside--it's important to understand about an environment like the
Android runtime is that it's divided into two parts:
* the Java VM that most people write to, that gives you access to the
widget toolkit, platform services, hardware and so on,
* and the native code environment, where you can call from the Java VM
into compiled C libraries and, with a bit more work, call back into the
Java VM from those C libraries.
(If you have any experience with the Java Native Interface (JNI), then
you probably already know how tedious it is to write C-level code that
calls back into the JVM.)
I've learned enough about writing code to bridge the C<->Java gap to be
able to say that, it's definitely within the realm of possibility to
write C code that can, say, instantiate Java objects (like GUI widgets)
and react when those Java objects' methods are called (like touch events
sent to a given GUI widget).
I personally would love to see steps taken toward making GUI option #1 a
reality--that is, writing a Tk-like wrapper at the C level around the
native widgets. Once that much was in place, it'd be easy to adapt my
code and scripts into making a turnkey "pack up your Tcl into an .APK"
build system. It might even be possible to do much of the hard work
automatically, by writing some sort of mechanical wrapper-generation
script. Any Java experts, can you speak up with any thoughts on this?
Another aside: it'd be possible to do nearly the same thing for iOS
support. Some time ago I embedded a Tcl interpreter into an iOS
project, which ran without problem on an iPad. It'd be a different
widget set, of course, though, and trying to develop a common set of
widgets between the two platforms might be tricky (i.e. more trouble
than it's worth).
And one last thing--I like your ideas about financial incentives. I'd
definitely submit a proposal or two for these sorts of projects if there
were some financial backing available.