Within the last time I was becoming silent cause we builded RapidFX the basic dialect language on the JVM. Extremely fast server applications with drag and drop designer XoJo like. With spezial training files reaching out to the most AI packages, well known syntax and access to the entire functionality of the JDK and all of it’s ecosystem.
Running on IntelliJIdea pro and communits edition, IntelliJIdea Plugin from Plugin Store for 79,- $ and plugin Download from Website for IntelliJ community Edition for 99,- $ per year. When ending using you can use the version you paid for. The compiler is entirely for free. Only Web module and the designers you need to pay this fee!
We have Objo, Buoy and now tsbRapidFX. It makes me wonder: how much fragmentation can such a small niche sustain before it becomes counterproductive and, in the end, everybody simply runs back to Xojo?
Wouldn’t concentrating all this talent and effort into fewer projects give the alternatives a much better chance of reaching critical mass?
Individually, we can build alternatives. Together, we can build an ecosystem strong enough to survive.
This language we builded before a time for our customers while XoJo wasn’s capable to fit the needs. This language is. It is hardened and reliable with a granted Service and rock solid runtime. Not in Development. Developed and coming as LTS release supported till December 2030 with Bug fixes. Follwting Releses are Feature releases, next LTS coming December 2030. So not a new build of a language but an implementation on the java virtual machine with the entire ecosystem and the features of code completion and precompiling at editing of intelliJ Idea.
On the other side: this is made for professionals to rely on this language and the ecosystem. It is builded . like Kotlin is - as a native Java Virtual Machine language. Blazing fast, stable and reliable. We support an ecosystem which is one of the biggest development ecosystems of the world. Our Web System can support thousands of concurrent users with low answering times and wysiwyg Screen Designer. So: there is a difference between something is in development and something which is released soon after years of production use.
I am not criticising your application, but the fragmentation within a very small niche. I am in no position to criticise your work, and please accept my apologies if I gave you that impression.
I am a team player.
My point is really in the last paragraph of my previous post. I genuinely think it is worth considering, because there is a serious issue behind it: individually we can build alternatives, but together we have a much better chance of building an ecosystem strong enough to survive.
Oh sorry…germans are sounding more riude they want to. It is so: we developed it after XoJo 2020 Release while customers needed an alternative for their WebApps and their embedded Desktop Apps. We started with the compiler and it growed to an entire system While we have all you can need what we can use immediately with RapidFX like PDF Box, jasper Reports, connectors to really all DB systems and so on we have decided: let’s release the system to the public cause we have to support it with or without pubic release. It eats really basic sourcode. Cause of the Java roots we deliver with an AI information pack which let’s claude and other (also local AI) develop in this language like they do in Java. While we wanted for the customers simple install and simple development we have a structure which provides this. IntelliJ has a world class language implementation which we used for code complation and code pre compile while editing and also solving tips. Simply a fast and working system for the customers. Load, install, click on new project for desktop or Web. Press run and it is immediately Wysiwyg in Browser and on Desktop.
Back to Xojo? It’s not like Xojo has minor little problems and people are just kicking the tires of these other products and then might go, “nah”. I mean all three of these new products are hungry and act like their customers matter, so the only scenario that matters as I see it is Xojo’s user base withers even faster and these three new ones duke it out.
As to whether there’s room for two or three of these – it’s an interesting question. It might be a mistake to assume it’s a tiny niche market just because they’re BASIC-inspired. I think there’s a market for approachable, streamlined yet powerful environments for developing line of business apps that transcends greybeards nostalgic for VB6 or Xojo in its RealBasic heyday. I’d think the departmental and small company markets are under-served and aren’t as prejudiced against Basic in favor of C-family languages as one might think. In any case if the language is strongly typed and has been brought into the modern era, if it doesn’t hobble you or get in its own way, I think the past ten years have shown us that people are open to different languages. After all, Go, Rust, Kotlin, PHP, Ruby, Julia, Python / Mojo and others are all in play. It isn’t just BASIC.
It’s kind of encouraging that Garry decided, heck, I’m putting Objo out there, and then it turns out Buoy and tsbRapidFX were percolating for some time as well and it forced their hand. So now you have three such dialects, one atop .NET, another atop Java and the other a custom LLVM-based implementation. Sounds like an embarrassment of riches to me!
Thank you for your reply, which I found very interesting.
Please don’t get me wrong. I want Objo, Buoy and tsbRapidFX all to be successful and to exist alongside each other. I only wanted to raise my concern about the relatively small market and the risk of fragmentation.
I agree with you and others that Xojo has itself to blame for much of its decline. If Objo, Buoy and tsbRapidFX can attract customers not only from Xojo, but also from outside the existing community, that would be great. And perhaps the market is indeed larger than I assumed.
Congrats, and like Objo with .NET you have choosen a strong foundation, Java.
The eternal fight between these two frameworks (looking back in the early 2000ies), between light and dark, enters a new stage
No, just kidding. all thriving new interpretations of Modern Basic dialects are welcome and clearly show me one thing: Basic as (professional) langauge is not dead in the year 2026.
No, it is not dead. As we strongly typed it and implemented directly on the jvm we have written this for our customer needs. The compiler is also running effortlessly on dalvik VM of Android. We remove at this time a few third party components from our drag and drop designer and replacing them with own components to provide the Android Plugin also. It’s not like a competitor tried to implement Android and press his language into this form with thousands of limitations: it works as a native Android language like Java or kotlin also. That’s one of the goodies of Java binary VM intermediate interoperability which we get for free implementing beside the kotlin lang and not on top of a proprietary VM.
Just for the sake of curiosity and extra information, Dalvik bytecode and DEX files are still used, but the current “Android VM” is called ART, Android Runtime. Dalvik VM (DVM) was gone around 2014 with Android Lollipop (but present and disabled for 4 years) then removed around 2018. The current Android Bytecode is even called “Android Bytecode” by many, but calling it Dalvik Bytecode is still ok, by now… because it is still the same bytecode for compatibility reasons.
Android Bytecode and instructions (the meaning of the codes) are very different from the Java Bytecode, e.g:
JVM instructions to add 2 ints
iload_0 ; push variable 0 onto stack // very stack based , slow
iload_1 ; push variable 1 onto stack
iadd ; pop both, add them, push result
istore_2 ; pop result, store in variable 2
ART instructions to add 2 ints (Dalvik code)
add-int v2, v0, v1 ; add v0 + v1, store in v2 // more direct , faster
Runs also on art runtime with air compiler without problems. My fault, sorry. The java code compiles without problem with the android Rapidfx Compiler.
' Counter — a real Android app in RapidFX.
'
' Build it and put it on a device:
' java -jar cli/build/libs/rfxdroid-0.1.0.jar --project examples/Counter/Counter.rfxdroid --run
'
' The difference from Hello.rfx: this program has no Sub Main, it has an
' activity of its own. The compiler sees that a class inherits from
' android.app.Activity and writes it into the manifest as the launcher — a
' manifest nobody has to write.
'
' The whole Android API is open, like any Java library: Imports, then New and a
' dot. The completion list in the editor comes from the same android.jar this
' is compiled against.
Imports android.app
Imports android.os
Imports android.view
Imports android.widget
Imports android.graphics
Public Class Counter
Inherits Activity
' The state of the app. A field of the class, as in any Basic.
Private count As Integer = 0
Private display As TextView
' onCreate is what Android calls when the screen comes into being.
' Overrides, because Activity already has the method; MyBase.onCreate,
' because Android insists the base class version runs first.
Protected Overrides Sub onCreate(state As Bundle)
MyBase.onCreate(state)
setContentView(BuildScreen())
Show()
End Sub
' The interface in code rather than in an XML file. Either works; in code a
' program needs no res folder and no R class.
Private Function BuildScreen() As View
Dim column As LinearLayout = New LinearLayout(Me)
column.setOrientation(LinearLayout.VERTICAL)
column.setGravity(Gravity.CENTER)
column.setPadding(48, 48, 48, 48)
column.setBackgroundColor(Color.parseColor("#101014"))
display = New TextView(Me)
display.setTextSize(72)
display.setTextColor(Color.parseColor("#E6E6E6"))
display.setGravity(Gravity.CENTER)
column.addView(display)
column.addView(NewButton("+ 1", Sub(v) CountBy(1)))
column.addView(NewButton("- 1", Sub(v) CountBy(-1)))
column.addView(NewButton("Reset", Sub(v) Reset()))
Return column
End Function
' A button with its caption and what it should do.
'
' The second argument is a lambda. View.OnClickListener has exactly one
' method, so a lambda fits it — and d8 turns each one into a real class at
' build time, because Android has no invokedynamic of its own.
Private Function NewButton(caption As String, does As android.view.View.OnClickListener) As Button
Dim b As Button = New Button(Me)
b.setText(caption)
b.setOnClickListener(does)
Return b
End Function
Private Sub CountBy(amount As Integer)
count += amount
Show()
' MsgBox exists on Android too — as an AlertDialog. A message that asks
' nothing works from anywhere; see Reset() for the case where the answer
' is needed.
If count = 10 Then
MsgBox("Ten reached.", rfxOKOnly, "Counter")
End If
End Sub
' A question, and the one rule Android forces on a Basic.
'
' MsgBox waits for the answer. It can only wait if it is not running on the
' screen thread — because the answer arrives from exactly there, and a
' thread waiting on itself stands still. A button press runs on the screen
' thread, so the question is asked from a thread of its own.
'
' Hello.rfx needs none of this: a program with a Sub Main already runs on a
' thread of its own, and MsgBox there is the blocking function it always was
' in VB.
Private Sub Reset()
Dim ask As Runnable = Sub()
If MsgBox("Really back to zero?", rfxYesNo, "Counter") = rfxYes Then
count = 0
' Anything that touches a view has to go back to the screen
' thread. runOnUiThread belongs to Activity.
runOnUiThread(Sub() Show())
End If
End Sub
Dim question As Thread = New Thread(ask)
question.start()
End Sub
Private Sub Show()
display.setText(CStr(count))
' Print goes to logcat — and so into the console that rfxdroid --run
' was started from.
Print "Count: " + count
End Sub
End Class
Simple application. Compiles, takes out apk which I can compile on Android Studio and install on Android with Version 16 with RapitX Android. What comes now: against the UX handling of Android we build a deterministic GUI with Drag and Drop designer for rapid application development. The compiler works.
Code completion example of the Files functionality. Even the AI understands how we wanna go forward in RapidFX with imported java nil Files the most comprehensive file working functionality and the most reliable and simple one. We have only a String? Use Path.of(“String”) and the String becomes a path. Superfast and simple. The completion works entirely in IntelliJ
