That’s why Xojo is still here: relentless adaptation.

Back when Xojo was REALbasic, version 1.0 only supported MacOS 8/9 and the 68000 and PowerPC processors. Since then we have seen countless changes in the computer technology landscape. Classic MacOS, Windows NT, Windows 95, Internet Explorer 6, Early versions of GTK on Linux, diskettes, and spinning hard drives are now ancient technology.

Xojo itself has changed dramatically over time as well. Though the basic idea of it, that you should be able to quickly and easily both learn Xojo and build apps, has not changed. Some code from an example project back then would be recognizable to a Xojo user today. Assigning variables, conditional statements, loops, even many classes like Graphics, FolderItem, TextInputStream, would all look familiar. That said, almost everything else has changed:

• The IDE was originally written in C++. It is now written in Xojo.
• There entire Xojo framework was originally written in C++. Today it’s a big blend of languages including quite a bit of Xojo.
• It originally had a single pass compiler. The entire compilation process has been rewritten. It is a modern, two-pass system that uses LLVM as its backend.
• REALbasic v1 could only produce desktop apps for MacOS 8 and 9 running on 68000 and PowerPC processors. Today, Xojo supports x86 and ARM processors, desktop apps for Linux, MacOS and Windows, mobile apps for Android and iOS and web apps.
• The documentation was originally almost entirely in printed form. It cost $30, weighed 49 ounces (just over 3 lbs.) and we shipped it to you right from our office. Now, the documentation is all online.
• The way users reported bugs and made feature requests has changed several times over the years.
• The community formed in mailing lists, and occasional Xojo events, now exists on our online forum.

And that adaption continues. We improve the frameworks with each release. We have added the ability to build Libraries. We are working on making web apps more responsive. We are continuing our march towards updating the Windows framework to WinUI. We are making changes to the Xojo IDE so that you can use AI tools such as Anthropic’s Claude Code, Google’s Gemini Code Assist, and Open.AI’s Codex, which, coincidentally, was almost the name we chose for what is now Xojo.

Companies survive by adapting, and Xojo, Inc. is no exception. Over the years we’ve changed everything from offices, personnel, and policies. While the team has changed over the years, many members have been with the company a very long time. In the tech industry, the average turnover is 2 to 3 years. Over the last 30 years, our average turnover is 7 years. Counting current team members, however, it’s a whopping 16.6 years! And among the current engineering team, there are 136 person-years of development on Xojo. We started working out of my apartment, then my house and then into an office here in Austin, Texas. Over time, about half of us found we were working from home a lot, so we decided to go entirely remote in 2008. We have changed many of our internal policies to make Xojo a great place to work. Every member of the Xojo team works so well together that it makes coming to work every day genuinely rewarding.

In general, only about 5% of businesses last 30 years. In tech it’s closer to 1%. It’s an honor to be a member of the tech industry’s 1% club!

What drives all of us at Xojo is helping you turn what started as an idea, into reality. We couldn’t have done it without all the dedicated Xojo users. That some of you have been with us for the entire journey, so far, is especially gratifying.

On behalf of the entire team, thank you for making Xojo possible.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

New Controls

Three new controls have been added to the Web framework in this release, aiming to close the difference gap between Web and the other project types.

WebSwitch is a toggle control that mobile developers will already be familiar with. It’s been available on iOS and Android for a while. It’s now available for web projects too, so if you’ve been approximating a toggle switch using a styled checkbox, you can finally retire that workaround.

WebColorPicker brings color selection to web apps in the same way DesktopColorPicker does for desktop. Drop it in from the Library, wire up the event and you have a color picker the Xojo way.

This is how WebColorPicker looks like in your browser:

The third new control adds barcode reading support. Your web app can now read barcodes directly from the user’s camera, from desktop or mobile browsers. This opens up a lot of practical use cases: Inventory systems, ticketing, product lookups, that previously would have pushed you toward a native mobile app.

Again, drop the Barcode control into your project and implement the events:

That’s it! Your web apps can scan a great variety of barcodes now. Including QR, Data Matrix, Aztec, PDF 417 and much more!

Icons on WebButtons

WebButton now has an Icon property. You can assign any WebPicture to it, or use one of the Bootstrap icons that are already bundled with the framework. It’s a small addition, but it makes a noticeable difference when building action-heavy interfaces where a label alone doesn’t communicate enough at a glance.

Add a button into your project:

Configure its Icon property in the Opening event:

Me.Icon = WebPicture.BootstrapIcon("key-fill")

If you don’t specify a color in BootstrapIcon, it will inherit the button caption color in this case. This is the easiest way to support Dark Mode with the new WebButton.Icon property, without doing any special tricks.

Here is how it looks like at runtime:

Dark Mode:

WebLabel: Semantic HTML and Proper Element Types

Two related changes landed for WebLabel in this release. The first is a correctness fix: the control was previously rendered using the HTML <label> element, which is semantically meant to label form inputs, not to display general text. That has been corrected.

The more interesting addition is that you can now choose which HTML element WebLabel renders as. If you want a label to be an <h1> or an <h2>, you can set that directly in the Inspector. This is useful not just for visual styling, but for accessibility tools and search engines that rely on page structure to understand content hierarchy.

Improving both, accessibility and making search engines happier, are some of our goals for 2026. You will continue seeing improvements in this sense.

WebTextArea Gets AddText

WebTextArea now has an AddText method, consistent with how the control works on Desktop and Mobile. If you’re writing code that targets multiple platforms, this kind of parity saves you from having to check which target you’re on, before appending text.

Scale Indicator on WebMapViewer

WebMapViewer now has a HasScaleIndicator property. When enabled, a small visual scale appears on the map showing real-world distance. It makes a difference in apps where users need spatial context. Field work, logistics or anything where “how far is that?” is a question users might actually ask.

Performance and Modernization Under the Hood

A few changes in this release won’t be immediately visible, but they improve things for everyone.

Bootstrap has been updated to v5.3.8 which fixes some issues introduced in v5.3.7 impacting Xojo. The TypeScript compiler has been updated to v5.9.3, and the compilation target has been bumped from ES6 to ES2020. Unused code in the Web Framework has been cleaned up to reduce the compiled bundle size.

Xojo has also removed its own internal usage of Modernizr. The library is still present for now so existing apps that rely on it won’t break, but it’s no longer used by the framework itself and will be removed in a future release.

If you’ve been meaning to audit your web app for performance, this is a good moment to look at SendEventsInBatches and LazyLoadDependencies on WebSession as well. Both now default to True on new projects, so if your existing app has them disabled, it’s worth trying them out. These properties have been around for a while already but were turned off by default.

API Consistency Cleanups

A few methods have been deprecated in favour of names that are consistent with the rest of the framework:

• WebApplication.AutoQuit → AllowAutoQuit
• WebListBox.ReloadData → ReloadFromDataSource
• WebRadioGroup.RemoveAllRows → RemoveAll, and RemoveRowAt → RemoveAt

Your existing code will still compile, but it’s worth updating these when you get a chance.

Wrapping Up

Between new controls, better HTML semantics, and a leaner runtime, 2026r1 is a worthwhile update for anyone building web apps with Xojo. Check out the full release notes for the complete list of changes.

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

In 2025, guest authors shared their expertise and real-world experience on the Xojo Blog. These posts bring fresh perspectives, practical solutions and deep technical insight that help other developers learn faster, solve problems more effectively and feel more connected to the Xojo community.

Guest posts in 2025 included:

• Martin T., Xojo MVP: Hide the Tabs in an Android MobileTabPanel Using Declares
• Martin T., Xojo MVP: Xojo for Android: A Two-Year Retrospective
• Martin T., Xojo MVP: It’s here – Android Design Extensions 4.0
• Anthony Cyphers, GraffitiSuite and Xojo MVP: Handling Feature Requests
• Kem Tekinay, Xojo MVP: MemoryBlocks For Speed: A Case Study
• Kem Tekinay, Xojo MVP: The Beauty of Binary Searches
• Jürg Otter: Build a Xojo Plugin with GitHub Actions
• Ezekiel Burke, Iron Elephant Solutions: Introduction to PocketBase: A Backend Alternative for Xojo Developers

We are always looking for users in the Xojo community who want to share a problem they’ve solved, a creative solution or an interesting project. If you’re interested in contributing a guest post or have an idea you’d like to explore, send it to me at alyssa@xojo.com.

In 2024, we introduced the Spotlight On series to highlight the work Xojo users do and their experiences using Xojo. Since many Xojo users don’t fit the mold of a traditional developer role, Spotlight On offers a fun and approachable way to learn how someone got started with Xojo and how they use it today. Spotlights can focus on an individual developer, a business or a specific Xojo-based project.

Spotlight On features in 2025:

• Spotlight On: GraffitiSuite
• Spotlight On: xDev Magazine
• Spotlight On: LX Aer
• Spotlight On: EKlectic Accounting
• Spotlight On: Raximus Studios
• Spotlight On: Richard Klingler
• Spotlight On: Enrique Contreras
• Spotlight On: Offroad Portal
• Spotlight On: Tim Dietrich
• Spotlight On: Sounds In Sync
• Spotlight On: Android Design Extensions
• Spotlight On: Aaron Andrew Hunt

If you’d like to be featured in a future Spotlight On or know someone in the Xojo community whose story would be great to share, we’d love to hear from you. Reach out with suggestions to me at alyssa@xojo.com.

The Xojo Blog is at its best when it reflects the voices, experiences and creativity of the community itself. Whether through guest posts, Spotlight On posts or shared ideas, we look forward to continuing to learn from and celebrate the people who make Xojo what it is.

Alyssa has been with Xojo for over 18 years. She loves solving problems and building community. You can reach her at alyssa@xojo.com or through any of Xojo’s social media channels. If you can’t reach her she’s probably out hiking the beautiful trails through her city of Portland, Oregon, or maybe enjoying a drink with friends by the river.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Getting Started

Jade uses Anthropic Claude as its engine, so before using Jade, you first need to sign up for an Anthropic API key to access Claude. You can do this from the Anthropic Claude Console.

From there you can create your account. After you’ve done that, you will want to get an API key to use with Xojo. Click on the “API keys” tab to see existing keys and create new ones. Click the “Create Key” button to generate a new key. In the dialog, give it a name to indicate its purpose.

When you click Add, the actual key will be shown. Copy it to the clipboard.

Note that you cannot see the key again after closing that dialog, but you can always create a new key at any time.

Now go to Xojo Settings and in the General tab, paste it into the “Anthropic API Key” field.

Go back to the Claude Console and click on the Billing tab to buy credits. Interacting with Jade requires credits. The amount of credits used depends on the complexity of your interactions. Until you get used to Jade and credit usage, you’ll probably want to start with a small amount, like $5, and disable auto-reload.

Using Jade

To use Jade, select Help->Ask Jade or click the Ask Jade button in the toolbar. You’ll get some short introductory text. Note: Using Jade requires an internet connection.

You interact with Jade similarly to a chat app by typing prompts in the conversation area (bottom section) and pressing Send. Jade will think for a moment and then display its response.

If Jade’s response includes Xojo source code you can click one of the buttons above the code block to copy the code to the clipboard or to directly insert it into the active code editor.

When interacting with Jade, keep in mind that although it remembers the context from the current conversation, it has no knowledge of prior conversations. Click the “Start Over” button to clear things and start a new conversation. Starting a new conversation is useful when switching to a different topic as it prevents Jade from relying on information you previously discussed that is no longer relevant.

The Export button saves the current Jade conversation to a JSON file which is a great way to save information you want to retain and refer to later.

Other Tips

• Jade currently uses Claude Sonnet 4, but this may change as newer models become available.
• The only thing Jade knows about your project is what type it is (Desktop, Web, iOS, etc.). If you want Jade to offer suggestions based on your code, you will need to copy/paste the relevant code into the Jade conversation area.
• Your Jade conversation is restored when the IDE restarts. If you get errors, ensure that you have valid internet access, that the API key is valid and you have a positive credit amount.

Wrap

We hope you find Jade helpful with your Xojo development. Remember, Jade in Xojo 2025r3 is the first version of an AI assistant for Xojo and will improve over time. In subsequent releases we expect to add more capabilities and project integration. Read more about Jade in Xojo’s Documentation.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

macOS 26 and iOS 26

Over time, Apple has brought the user experiences of macOS and iOS closer together. macOS 26 and iOS 26, now aligned in version numbers, also share more similarities than ever in their user experience. These updates represent the most significant user experience changes from Apple since iOS was introduced in 2007 and Aqua for macOS seven years earlier. With such a big update, especially when designing elements to work on both large computers displays as well as small smartphone screens, it’s no surprise there’s some tweaking requiring after release. Clearly, Apple is still refining its platforms.

We continue to update Xojo as Apple defines its preferred user experience, ensuring that you can deliver the best possible experience to your users.

WinUI

We are also hard at work upgrading our Windows framework to WinUI, providing a modern user experience for Windows apps. You can see our progress in each release by enabling the Use WinUI (Experimental) option on the Advanced tab in Windows build settings. The “Experimental” label is a reminder that the feature is still evolving, and it will be removed once WinUI is fully ready. Our goal has always been to keep Xojo on a steady path, prepared for whatever challenges lie ahead.

Conclusion

On behalf of the entire Xojo team, I can say that we love what we do and we appreciate your support in allowing us to do it. We are Xojo users ourselves (after all, we make Xojo with Xojo) and we enjoy seeing what you make with it. With that in mind, feel free to tell us about your creations. Send your screenshots, descriptions and your story to hello@xojo.com.

What is a Library?

A Library is a collection of pre-written, reusable code containing methods, classes and UI. Up until now, the way to distribute a Library for use with Xojo was to create a Plugin or to manually re-use project items across projects. Both have pros and cons.

Plugins are compiled and do not expose source code, but plugins cannot be created using Xojo itself and are typically created using C/C++ along with the Xojo Plugin SDK. Sharing project items is fine for internal projects or open-source projects, but less ideal for commercial libraries. They can be harder to manually add to a project and are recompiled along with the project, slowing the debug process.

With a Xojo Library, you can now create your own compiled Library using Xojo itself. This Library can contain nearly any Xojo project item and can be easily used in other Xojo projects because it is distributed as a single file.

At a high-level, you create your Library in Xojo, add your project items to it and built it into a Library package file. Other projects can then use this Library package, which gives them access to the items you included in the Library.

Creating a Library

Here is a brief overview of how you create a Xojo Library:

1. In a Desktop, Web, Console or iOS project add a Library by choosing Insert->Library.
2. Add the project items you want to the Library. Any Xojo project item is supported, except for Worker.
3. Build the project. It will build the main app (which should serve as a test app for your Library) and a separate Library package file (with extension .xojo_library).
4. You can put this Library package alongside another project (on the drive) and it will be loaded when that project is opened by Xojo. You can then use the classes, methods and UI contained in the Library within your project. If you instead put the Library in the Plugins folder, then it will be available for all projects.

This is all best demonstrated by a quick example. Go ahead and create a Desktop project and add a Library to it, which adds a Library1 project item to the Navigator. Change its name using the Inspector to LibHello.

While LibHello is selected, choose Insert->Class. This adds Class1 to it. This new class is now part of the Library. With Class1 selected, change its name to StringStuff.

You can now add whatever methods or properties you want to the class. For our example purposes here we will add a simple method that reverses a string.

Public Function ReverseString(s As String) As String
  Var newString As String
  
  For Each c As String In s.Characters
    newString = c + newString
  Next
  
  Return newString
End Function

The Library could contain many other things of course, but to keep things simple this Library will have just the single class with its single method. Here’s what it looks like in the project:

The first thing to do is to test this Library ReverseString method. Add a button to Window1 and have it call the function, verifying the result.

Var stuff As New StringStuff
Var result As String = stuff.ReverseString("Xojo")

MessageBox(result)

When you run, you can see the output:

So far this is all not much different than you would normally be doing with a Xojo project. The next step is to create the Library package for use by other projects.

In the Build Settings area, select Shared. This is where you can enter some information about the Library that can be seen by those that use it.

• In the Version field, enter “1.0”.
• In the Copyright field, enter “Acme, Inc.”
• In the Description field, enter “A Xojo Library test.”

Also in the Build Settings area, check the boxes for the platforms you want the Library to work on. In most situations, you will want to select macOS, Windows and Linux.

Now click Build. This builds the app as usual, but also creates a separate Library package file (LibHello.xojo_library for this example) that can be used with other projects.

Using a Library

Now that you’ve created your Library package, you can use it with other Xojo projects. The Library built above was created within a Desktop project, so it can only be used with other Desktop projects. So the first thing to do is to create a new Desktop project (call it MyTest), save it and close it.

Once it is saved, go to Finder or Explorer and place a copy of the LibHello.xojo_library file (from its build location) alongside this saved project file.

Go back to Xojo and open the MyTest project. The project will open normally, but the Library will also be loaded up as well. You can see this by showing the Xojo About window and going to the Plugins & Libraries tab. There you will see the Library name along with the information you entered about it earlier. (Double-click on the Library row to show the description.)

Going back to the MyTest project, you can now use the Library with it. Add a button to the window and have it call the StringReverse function the same way you did before:

Var stuff As New StringStuff
Var result As String = stuff.ReverseString("Xojo")

MessageBox(result)

Now run the project and it will use the class and its method just as if it is part of the project.

That’s the basics of how to create and use a Library. You can of course include whatever you want in the Library, but as with any library it is usually a good idea to keep things well-organized.

Considerations

• A Library package (which uses ZIP) contains compiled code and definitions of the public API in that code.
• Only a single Library project item can be added to a project when developing.
• A project can use any number of Library packages.
• For a built library to work on all OS platforms, then those platforms must be selected before building it.
• Libraries only support 64-bit builds.
• Library packages are placed alongside the project file and are loaded when the project is loaded.
• Library packages can also be placed in the Plugins folder. These libraries will be loaded separately for each project.
• If items in your Library have dependencies outside the Library, then the Library package will not be usable in another project without those dependencies. For example, if a Library class method references a class in the main project, then it will build without an error (because the main project is available), but if you use that Library in another project you will get linker errors.

Why a Preview?

We are referring to this initial version of Xojo Libraries as a preview release because it is very new and we want to give more developers a chance to test with it so we can iron out issues. We encourage you to try moving your existing reusable code collections over to a Library to help test, while also improving your workflow. If you have any open-source projects that are essentially a Library, you might try building them into a Xojo Library package as well.

You can make Library packages available publicly, but you should probably tag them as a preview, beta or test version until we remove the preview label.

Read more about Libraries in the Xojo Documentation. Check out these open-source projects on GitHub that have recently been updated for API 2.0 and now have a Library that you can download from the Releases section:

• Visual Basic Library
• FileMaker Library
• WinAPI Library

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

While license pricing is going up, we’re also increasing long-term value for our loyal users by doubling the auto-renewal discount from 10% to 20%.

What’s Changing Today

Beginning today, new Xojo Desktop, Web and Mobile licenses are $499/year. New Xojo Pro is $999/year. Xojo Pro Plus will remain $1999/year.

The Xojo Lite license is being retired and is no longer available. Existing Lite licenses will continue to function as expected. Lite renewals will be available until August 4, 2025. In order to receive future updates, existing Lite license holders will need to upgrade when their current license expires.

What is Coming Up

While the new pricing is in effect for new licenses starting today, we want to give existing users time to renew under the current pricing. The updated pricing for renewals and upgrades will take effect on August 4, 2025. One and two year renewals are available on our website. New and expired licenses can be renewed anytime. If you are interested in renewing for a longer period, please contact our support team.

The standard auto-renewal discount is doubling from 10% to 20%. Additionally, users who maintain an unexpired license¹ will receive even greater discounts over time: 25% after five consecutive years and 30% after ten years.²

We do not make this decision lightly. Our goal is to ensure that we can continue to invest in Xojo. This update reflects not only inflation over recent years but also the expanded value we’ve added to Xojo.

We remain committed to providing excellent value and keeping Xojo more affordable than many alternatives in the market. Raising prices today helps us keep that promise long-term.

Note: These changes do not affect the Xojo IDE which remains free for downloading, development and testing. You can still install Xojo on as many machines as you like and run your projects using the free IDE. Building for Linux and Raspberry Pi also remain free and do not require a license.

1. Updated to include all renewal types: Maintain an unexpired license, using auto-renewal or manual renewal, to receive these discounts. Renewals placed before a license expires always include the full 12 months of support. ︎
2. Discounts are automatically applied based on your auto-renewal history beginning August 4, 2025 and are not retroactive. ︎

Added Support for WebStyle States

Working on Desktop projects is all fun and jokes. You can just change how the whole application looks every time your application users move their mouse one pixel to the left. Latency? Who cares!

In order to achieve the same results, WebStyle has been improved to support states. Hover, Pressed and Visited.

• WebStyle.Hover
  This is the style that will be applied when the mouse is over the element
• WebStyle.Pressed
  This is the style that will be applied when the user is pressing a mouse button in the element
• WebStyle.Visited
  This style can be used with WebLink instances. Used to let the user know the browser has visited that link in the past

Consider the following WebContainer:

In this case, it’s just a container with a WebLabel inside.

The Opening event contains the following code:

Please note I’m using named colors. You can read more about named colors in Introducing Named Color and CSS Classes in Xojo Web. If you try using another Bootstrap theme, the same code will use the new color palette without modifications.

Here is the result:

Combined with WebStyle.AddTransition, it opens the gates for more interesting GUIs. Let’s add some transitions to our code:

Let’s try the project again:

Neat! Let’s go crazy for a second with more complex effects:

The result:

You should definitely avoid going that crazy, this is just to show the possibilities. As Dr. Ian Malcolm said … “Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.”

WebContainer.Pressed

Speaking about pressing on things, WebContainer.Pressed event is now available, so you don’t need to place a WebLabel or a WebContainer on top just to capture that event anymore. The event comes with some coordinates, just in case you need them.

The result:

Other changes

WebToolbar.Resized

Trying to tweak your design for different screen sizes? If WebToolbar’s automated behavior is not enough, you can implement the new WebToolbar.Resized event and adapt the contents. This is useful when you are reusing the same WebToolbar subclass in multiple WebPages. You will be able to place this code in just one place.

Exporting maps with WebMapViewer

Same as with MobileMapViewer. You can now use WebMapViewer.ToPicture method to export the current map. Like WebChart.ToPicture, due to the asynchronous nature of Web projects, the picture will be available in the new WebMapViewer.RequestedPicture event.

Updated DataTables

Last, but not least, DataTables has been upgraded from v1.13.4 to v2.2.2.

That’s (not) all!

As always, please make sure to check the release notes for a detailed list of new features and bug fixes. The Web framework is built on top of Xojo, new global features or bug fixes also applies to Web, including improvements to Console projects. Xojo Web is “just” a big Console project.

Thank you everyone for reporting, testing beta builds and giving us feedback.

Happy coding!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

For the most part, writing drawing code will just work because you use Xojo’s Graphics class for Android, Desktop and iOS projects. Web projects, however, don’t use the Graphics class. The WebCanvas control’s Paint event is passed a WebGraphics object. While the Graphics and WebGraphics classes have a lot in common, sharing many of the same methods with the same parameters, they are two distinctly different classes from the perspective of the Xojo compiler. That means that while the code you write will look almost identical, you still have to use a Graphics object for Android, Desktop and iOS projects and a WebGraphics object for Web projects.

Your instinct might be to simply write the code for one and then copy it to the other projects, changing Graphics to WebGraphics for Web projects. This will of course work, but then you have to remember to do this copy/paste/change operation every time you update your code. That’s not ideal.

Graphics vs. WebGraphics

With Xojo, the code can be written in such a way as to automatically handle the difference between Graphics/WebGraphics. Most often your graphics methods will be called from something that provides a Graphics or WebGraphics object for you to draw into such as a Canvas control’s Paint event. From there your code will call your methods that do the drawing. The problem is that your methods can’t use a Graphics or a WebGraphics type as a parameter because Graphics is not going to work for your Web projects and WebGraphics doesn’t exist in any framework except the Web framework. Thus using it anywhere else will result in a compiler error.

Using a Variant

Getting around this limitation is, fortunately, quite easy. Instead of using Graphics or WebGraphics as a parameter type, you use Variant. A Variant can hold any type of data from Strings to Integers, to Graphics to WebGraphics and more.

Once your drawing method gets the Variant though, it can’t use it to draw. It can only use a Graphics or WebGraphics objects. The trick is to then copy it into a Graphics or WebGraphics class variable:

Var g As Graphics = context

or

Var g As WebGraphics = context

The problem you now face, as mentioned earlier, is that WebGraphics only exists in Web projects. That means you have to write your code in such a way that you will declare the variable g as a Graphics object in Android, Desktop and iOS projects and as a WebGraphics object in Web projects. This can be achieved via conditional compilation. This is a simple technique that tells the Xojo compiler to only compile code into your app if conditions you specify are met. In this case, if you’re targeting Desktop or Mobile, it should compile in the line that uses the Graphics type, and if you are targeting a Web app, the line that uses WebGraphics. To conditionally compile, you just need to add that conditional code around these two lines:

#If TargetDesktop Or TargetMobile Then
   Var g As Graphics = context
#EndIf

#If TargetWeb Then
   Var g As WebGraphics = context
#EndIf

Since a project must be only one of the above types, when you run or build your project, the appropriate line of code will be compiled in. From there, you now have a variable (g) of the right type can use this to draw whatever you like. For example, there are four identical example projects (one for each project type) that show off this technique. They can be found in the Xojo IDE by choosing File > New Project, clicking on Examples, choosing the Graphics folder in the list and then the Cross-Platform Drawing folder. The examples all draw a checkerboard that looks like this:

They all contain the an identical Checkerboard class that handles the drawing. This class has DrawBorder and DrawCheckers methods that both take a Variant as a parameter. In each project is a Canvas control whose Paint event calls these methods:

Var cb As New Checkerboard
cb.DrawBoard(g)
cb.DrawCheckers(g)

The full DrawBoard method looks like this:

#If TargetDesktop Or TargetMobile Then
  Var g As Graphics = context
#EndIf

#If TargetWeb Then
  Var g As WebGraphics = context
#EndIf 

Var boxSize As Integer = Min(g.Width/8, g.Height/8) 'The size of the box
'Draw the rows
For y As Integer = 0 To 7
  For x As Integer = 0 To 7
    'Switch colors for each box in the row
    If g.DrawingColor = Color.Black Then
      g.DrawingColor = Color.White
    Else
      g.DrawingColor = Color.Black
    End If
    'Draw a box
    g.FillRectangle(x * boxSize, y * boxSize, boxSize, boxSize)
  Next
  'Switch colors again for the beginning of the next row
  If g.DrawingColor = Color.Black Then
    g.DrawingColor = Color.White
  Else
    g.DrawingColor = Color.Black
  End If
Next

In the example projects, check out the DrawCheckers method as well. It uses the same technique. What is great about this is that this class can be copied into any Android, Desktop, iOS or Web project and it will indeed just work.

Checking Out the Examples

There are four example projects (one for each project type – Android, Desktop, iOS and Web) that demonstrate the technique explained here. You can find them in the Xojo IDE by choosing File > New Project, clicking on Examples, choosing the Graphics folder in the list and then the Cross-Platform Drawing folder.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Some projects require additional entries in the generated Info.plist file. Previously, the only way to include these entries was to create the file manually using an external text editor, then drag and drop it into the project’s Navigation area. This allowed its contents to be merged with the entries automatically generated by Xojo in the final Info.plist file within the app bundle.

Now, the Property List Editor in the Xojo IDE provides a simpler way to add these entries. Once added, you can even export the contents to an external file, making it easy to reload them later for other projects that require the same set of entries. This saves time by eliminating the need to manually re-enter them.

What about projects that already reference an external Info.plist file? No worries—Xojo will automatically merge its contents with the entries added via the Property List Editor. If the same key exists in both the external file and the Property List Editor, the value from the Property List Editor will take precedence, overriding the one in the external file.

As for the types of data that can be added to the Property List Editor, the expected options are offered:

For collections:

• Dictionary
• Array

For primitive values:

• Number
• String
• Boolean

For primitive value entries, the Editor allows you to convert them to any of the other two supported primitive types. For example, if you add a Number entry, you can later select it and convert it to a String or Boolean type as needed.

Of course, the entries added through the Property List Editor are applied and saved to the project file in addition to any changes made using the Property List Editor. The next time you open the project in Xojo, you’ll find the previously applied Info.plist entries already in place.

Tip: If you’re using the new Publish feature to send your macOS apps to App Store Connect, you can simplify Apple’s encryption compliance process by adding a new Boolean entry in the Property List Editor with the following values:

Key: ITSAppUsesNonExemptEncryption
Value: False

By doing this, you won’t need to manually go through the “Manage” option for Apple’s encryption compliance on the App Store Connect website—provided your app does not actually use encryption that requires disclosure.

In Summary

Whether you’re developing macOS or iOS projects, the integration of the Property List Editor in the Xojo IDE streamlines the process of managing additional Info.plist entries. You no longer need to manually create and import external files —now, you can add, edit, and reuse entries directly within the IDE. This not only saves time but also ensures consistency across multiple projects!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

The End Result

The latest drag and drop example has a functional GUI that looks professional and feels intuitive. All without writing a single line of JavaScript (we will enhance it a bit with some CSS, though).

Please note this is a sample project created to explore drag and drop, not a full featured Kanban board. I’ll omit on purpose things like persistence. The complete project can be found in the Examples section of the IDE, under Platforms > Web.

Let’s walk through how to make it happen.

Creating the Required Components

First, we need to define the building blocks of our Kanban board. In Xojo, WebContainers are perfect for modularizing reusable UI elements. Here’s what we’ll create:

• KanbanCard
  A WebContainer to represent each task card. It’ll have a simple label for the task name (e.g., “Write blog post”) and maybe a colored border or handle to indicate it’s draggable. Add a WebLabel for the text and set its properties in the Inspector to make it visually distinct.
• KanbanCardContainer
  Another WebContainer to act as a column. It’ll hold multiple KanbanCard Containers and serve as both a drag source (where cards come from) and a drop target (where cards land). Include a WebLabel at the top for the column title (e.g., “To Do”) and a rectangular area below it to house the cards.
• Main Page
  A WebPage to host everything. This is where we’ll arrange our columns side by side.

In the Xojo IDE, drag a WebContainer onto your project for the Card, another for the Column, and set up three instances of the Column Container on the main WebPage (“To Do,” “In Progress,” “Done”).

KanbanCard

This component will be pretty easy to build. It is basically a WebRectangle with a WebLabel that we will use for the Title. To make it easier to update, I’ve added a Title Computed Property that will update the TitleLabel if needed.

For the background WebRectangle, we will use the following ColorGroup. Please notice Xojo added support for Named colors, that will rely on the current Bootstrap theme, supporting Dark Mode:

As you can see, BackgroundRectangle and TitleLabel controls are implementing the Opening event. This is just to set the mouse cursor that will be shown when we hover:

Me.Style.Cursor = WebStyle.Cursors.Move

The container itself is also implementing the Opening event. This is to make this control draggable, using the following line of code:

AllowTextDrag(WebDragItem.DragActionTypes.Move)

Any descendant of the WebUIControl class is draggable. And yes, that includes custom controls created with the Web SDK.

For the WebDragItem.DragActionTypes Enumeration, you can choose one these options:

In this case we will only be allowed to “Move” a card from one place to another.

There are cases where it makes sense to support multiple drag action types. In your operating system’s file browser, when you drag and drop files and folders, you can change between Move, Link or Copy by using Keyboard shortcut combinations. Depending on the drag action type, the element will be moved, a symbolic link will be created, or it will be copied, respectively.

Normally you will implement just Move or Copy, but keep in mind it’s possible to have more (at the cost of increasing the learning curve of your application for your users)

Allowing something to be dragged is the first of two steps. You also need a place to drop these items into.

KanbanCardContainer

This container will be more elaborate, but should be easy to follow. Let’s see how it works at runtime, with some annotations:

The WebLabel we used for the Title and the WebButton used for adding new cards are positioned manually in the IDE designer. Same as the invisible WebRectangle holding the KanbanCard items and the KanbanAddCard custom button.

But instead of placing our cards manually, we’ll take advantage of the browser’s capacity for doing this job for us. We just want to add them dynamically at runtime and let the browser stack them vertically, automatically. We also want the browser to display a scrollbar if the columns have several cards.

Here is the code we will add to the WebRectangle:

// Let the framework know we want to let the
// browser place the items automatically
Me.LayoutType = LayoutTypes.Flex

// This style will ensure cards won't be
// placed horizontally by the browser
Me.Style.Value("flex-direction") = "wrap"

// If there are more cards than available
// space, this style will allow the user
// to scroll
Me.Style.Value("overflow") = "auto"

Let’s add some methods to add and remove cards at runtime.

• AddCardWithTitle(title As String)
• AddCardWithTitleAt(title As String, index As Integer)
• RemoveCardAt

Moving Cards Between Columns

Here’s where Xojo’s drag and drop shines. Each Card Container needs to be draggable and each Column Container needs to accept dropped cards. In Xojo:

1. Make Cards Draggable: Open the KanbanListCard in the IDE and implement the Opening event. Enter this code:
   AllowTextDrag(WebDragItem.DragActionTypes.Move)
2. Accept Card Drops: Open the KanbanCardContainer and implement the Opening event. This is the code we need in order to accept drops:
   AcceptTextDrop(WebDragItem.DragActionTypes.Move)
3. Remove from Source: To move (not copy) the card, in the source Column’s DragEnd event, remove the dragged card from its original parent after a successful drop.

With this, you can drag a card from “To Do” to “In Progress,” and it’ll visually jump columns. Xojo handles the heavy lifting. No JavaScript or DOM manipulation needed!

The Hard Part: Reordering Cards

Reordering cards within a column, or dropping a card into another column in a specific position is trickier. You need to detect where the card lands among its siblings and adjust their positions. Xojo’s drag and drop doesn’t natively sort UI elements, so we’ll simulate it.

There are several ways to achieve this, let’s explore some options.

One would be to deal with X/Y coordinates. Once you drop a card, you could take a look to see where the card landed, compare the coordinates with the other cards and reorder them accordingly. In desktop and mobile projects this could be a valid solution. In web projects, dealing with specific coordinates might work, but there are more accurate and easier solutions.

The second way could be good enough in most cases. Cards could also accept drops so, if you drop one card on another, we just have to put the card being dropped in the position where it’s being dropped, and push down the rest of the stack. This way you won’t need to scratch your head and deal with screen coordinates or control dimensions. The end result will be based on this idea.

But what should we do to generate the gap between Cards? Maybe you can create a transparent Container that also accept Card drops, to simulate the gap between cards.

This would work for you, and I honestly recommend you to give it a try, it’s super easy to implement and it will just work. If you don’t want to explore the CSS rabbit hole, that’s fine, this can be your bus stop.

Two downsides:

• You won’t have animations
• You will double the amount of controls on screen (performance may suffer)

I went in another direction though. Using some CSS, you can add and modify margins on the fly, with neat transitions. In my sample project, the margin between cards is managed by the `margin-top` CSS style.

And here is where the Xojo Framework helps. To make styling easier, it adds a CSS class to the element being dragged and also to the element where the mouse is over, when it’s accepting a drop.

dragging – The HTML element being dragged will have this property
dragover – The HTML element under the other element being dragged

In this case, the “Bar” card will receive the dragging CSS class, while “Test #2” will receive the dragover CSS class, while the “Bar” car is above.

I’ve added some transparency to elements with the dragging class. As you can see in the screenshot, the “Bar” Card opacity is set to 30%.

For dragover class, I’ve added some margin and transitions. If you drag something into a card, the top margin will grow, simulating it’s making room for the card you are about to drop.

Here is how the HTML Header section of the sample project looks like. It isn’t too much code, but it does uses some somewhat advanced CSS tricks:

This approach keeps cards neatly stacked and sortable. It’s the “hard part” not because you will have to write a lot of code, but because you’ll actually have to think a solution that won’t require roundtrips between the browser and the server. Xojo’s event system makes it manageable without JavaScript, and with some CSS, the result will be great.

Some CSS Enhancements

In some cases I’m using shadows and border radius using the Bootstrap’s CSS classes.

As you can see, I’m using rounded-2 for the border radius, and shadow-sm to easily add a shadow to the cards.

You can read more about this in the following blog post:
Introducing Named Color and CSS Classes in Xojo Web

There is a related sample project you might want to check:

Closing Thoughts

This has been a fun experiment to explore the Xojo Web drag and drop feature. Give the sample project a try and explore each control to see how it’s been created. I can’t recommend enough that you try to build it from scratch (and ask in the forum if you get stuck!)

We can’t wait to hear about how you plan to introduce drag and drop into your projects. Don’t be shy and create a forum thread to show what you have built, or what you are working on.

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

This control is available in the Xojo Library panel and works similarly to iOSMobileUserControl: drag it onto a layout and implement the CreateView event.

Declare Function Button Lib "Kotlin" Alias "android.widget.Button(context as android.content.Context)" (context As Ptr) As Ptr

Var bp As Ptr = Button(App.AndroidContextHandle)

Return bp

The above code uses a Declare to create a native Button and returns it so that it can be displayed in a layout.

By using AndroidMobileUserControl and Declares to access the Android UI library, you can create your own UI controls. I look forward to seeing what the community creates!

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

As Senior Engineer Paul Lefebvre wrote back in 2022, Xojo added the ability to create Code Assistants starting with Xojo 2022r1. Code Assistants are functions that manipulate the code selected in the Code Editor to help with various code editing tasks. Code Assistants are written in XojoScript, but XojoScript has no access to the Xojo Debugger. Fortunately, there’s a simple solution to this problem.

Xojo’s Code Assistant Tester example project makes it easy to test and debug your code before you create your Code Assistant. Go to File > New Project, click on Examples then open the IDE folder to find it. With this example, you can enter the code that would go into your eventual XojoScript that will be your Code Assistant. Because this code is in methods in Xojo itself, you can test it and debug it with the Xojo Debugger.

Here’s a quick video on how to use Code Assistants and the Code Assistant Tester:

If you write some handy Code Assistants, consider sharing them on the Xojo Forum they could be useful to others in the community.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

When I started sharing Spotlight On posts last year, Alvaro Fontán was a Xojo developer that immediately came to mind as someone who should have a spotlight shone on their work. Alvaro has been to multiple Xojo Developer Conferences and is a great guy to get into a conversation with, whether about Xojo or a lot of other topics. His Offroad Portal project is a excellent example of an app that solves a problem and helps a community of people. This project continues to grow with 26 current administrators around the country distributing volunteers to all 50 states.

Mac, Windows or Linux?

I develop in a Mac environment but create applications for Windows, Mac, and Web using Xojo. I primarily use MySQL for all the apps I build and frequently integrate APIs into my projects. I also enjoy incorporating HTML and CSS into Xojo applications to enhance their functionality and user experience.

What do you wish more people would ask/talk to you about regarding programming?

I wish schools provided more opportunities for young minds to explore programming. Today, everyone carries a powerful computer in their pocket, yet most people have no idea how to create custom tools to truly harness its potential. I think Xojo would be an amazing starting point for them.

How would you explain your most recent project to a 5 year old?

Many people with little off-road experience end up getting stuck, facing technical difficulties, or breaking down. To address this, we’ve developed a web application that captures the incident location and allows users to share photos, notes, and contact information. Once a request is submitted, administrators verify the situation and forward it to local volunteers across all 50 states. Currently, we have 3 general administrators, over 26 regular administrators, and more than 13,000 dedicated volunteers. Additionally, we have the support of hundreds of thousands of extra volunteers from local off-road organizations we collaborate with. Our application enables real-time tracking of the recovery process, allowing all involved parties to communicate and coordinate effectively.

What’s next on your “Learn Next” list?

I’m exploring ways to integrate AI to streamline the work of our administrators, as much of their tasks are repetitive and time-consuming.

What is something that has surprised you about coding in the last 10 years?

Sometimes, after spending hours developing a solution and testing it for days, a user will discover a bug by doing something I never thought to try in my own app.

Xojo isn’t the only tool in your kit. What is a piece of software more people should know about?

MySQL, CSS, HTML, Python, AppleScript, JavaScript. 

What is something you worked on recently that you want to talk about?

I received a request from an elderly person who had never used a computer and wanted to learn how to use a simple word processor. After searching for an option that was easy enough to simplify saving, loading, printing, and emailing, I couldn’t find anything suitable. So, in just a few hours, I designed a simple interface using Xojo, integrated it with a MySQL back end, and made it extremely user-friendly—with autosaving, non-destructive editing, and buttons to navigate through different versions. There’s one click to print and one click to send a copy by email.

It may sound simple, but the more I thought about it, the more I realized how overwhelming it must be for someone who’s never used a modern UI to complete even the most basic tasks. Xojo turned out to be the perfect tool for quickly developing solutions like this one.

When did you start using Xojo?

1998/99.

How did you find Xojo?

Can’t remember.

What did you first build with Xojo?

Small apps for helping with things around the office.

When was that?

The first apps I developed were in the early 2000s. In 2002, with my background in graphic design and while working for a sales magazine, I created the software we used to produce the magazines, utilizing Xojo and AppleScript with Quark. In 2004, I was hired as a full-time developer for the first time, where I automated the creation of brochures and booklets using Xojo and AppleScript.

By 2007, I advanced further and was hired by a large corporation that owned 25 newspapers. There, I developed a photo database that managed and shared about a million photos using Xojo and MySQL. Later, I built an editorial system that automated newspaper design and managed web content for over 200 editors, reporters, and photographers, integrating Xojo with Joomla and later with WordPress for smaller sub-sites.

When the company was sold, I continued maintaining dozens of systems I had developed, working as a contractor for the new owners.

What do you build with it now? 

Our application for Offroad Portal is what consumes most of my time.

Do you earn a living with Xojo? 

Yes, absolutely. 

Do you use it for your hobbies? 

It’s a tool I use, much like someone would use a ruler or a calculator. For me, thinking about implementing solutions with Xojo comes naturally.

What’s your biggest Xojo success?

The newspaper software was my proudest achievement. It was a massive undertaking with countless challenges, but also a lot of fun. I worked on that project for over 12 years, and I vividly remember the code reaching over 120,000 lines. I started as the sole developer, but eventually, I was able to build a small team. This allowed me to delegate parts of the code to other developers and get help with web integration.

Thank you to Alvaro Fontán for answering questions and sharing his Xojo experience with the community. Learn more about Offroad Portal.

If you have an app, a project or a person you want to see featured in Spotlight On, tell us about it!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

I first created Storm in 2008 when I was working on consulting projects as a way to more rapidly create database apps for clients. It has been updated over the years and the latest version is available on GitHub:

Storm

An ORM lets you write code like this to set database column values and save them:

Var dodgers As New Team
dodgers.Name = "LA Dodgers"
dodgers.Coach = "Dave Roberts"
dodgers.Save

Team is a table in the database with a corresponding class in Xojo that inherits from Storm.DBObject.

The included demo projects shows how you can implement a simple UI for a database with Team and Player tables.

The docs for Storm are contained within its Github repository wiki.

In addition to accessing the full repository on GitHub, you can also download Storm as a ZIP.

I’ve created a forum topic for you to start sharing your Year of Code projects and I’ll also be sure to include this one as well. Remember, participants can win a $100 to use in the Xojo Store!

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Year of Code Project

• Year of Code: Kickoff
• January Project: Desktop Apps | Forum Discussion
• February Project: Database Apps | Forum Discussion
• March Project: Web Apps | Forum Discussion
• April Project: User Interface | Forum Discussion
• May Project: Mobile Apps | Forum Discussion
• June Project: Code Sharing | Forum Discussion
• July Project: Charting | Forum Discussion
• August Project: Console Apps | Forum Discussion
• September Project: Games | Forum Discussion
• October Project: Multi-Platform | Forum Discussion
• November Project: PDF | Forum Discussion

How to Play:

Each month we’ll announce a new theme and share an example project of our own. Share your projects to the Xojo Forum thread for that month via GitHub (all the links you need are posted above ↑ ). Learn how to use Xojo and GitHub.

The Prizes:

Monthly winners get $100 at the Xojo store. Every month you submit a project is another chance to win the grand prize. The grand prize is $250 cash plus a Xojo Pro license and a year of GraffitiSuite and will be announce in December. Learn more about the prizes.

XojoText is a simple text editor that lets you edit multiple files in one window with a list of files in the left sidebar. You can create new blank documents, documents from a selection in another document or from the clipboard.

It is based on the XojoText example that is included with Xojo, but enhanced in these ways:

• Word, character, line counts shown at bottom of editing area.
• Recent Items menu.
• Window menu.
• Saves window position.
• Prompts to sae changes.
• Contextual menu on files in the sidebar.
• Click “x” to close files in the sidebar.

Suggestions for improvements and things to add:

• Find/Replace capability.
• Printing.
• PDF generation.

I’ve created a forum topic for you to start sharing your Year of Code projects and I’ll also be sure to include this one as well.

You can download the XojoText project from GitHub here: https://github.com/paullefebvre/XojoText

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Year of Code Project

• Year of Code: Kickoff
• January Project: Desktop Apps | Forum Discussion
• February Project: Database Apps | Forum Discussion
• March Project: Web Apps | Forum Discussion
• April Project: User Interface | Forum Discussion
• May Project: Mobile Apps | Forum Discussion
• June Project: Code Sharing | Forum Discussion
• July Project: Charting | Forum Discussion
• August Project: Console Apps | Forum Discussion
• September Project: Games | Forum Discussion
• October Project: Multi-Platform | Forum Discussion
• November Project: PDF | Forum Discussion

How to Play:

Each month we’ll announce a new theme and share an example project of our own. Share your projects to the Xojo Forum thread for that month via GitHub (all the links you need are posted above ↑ ). Learn how to use Xojo and GitHub.

The Prizes:

Monthly winners get $100 at the Xojo store. Every month you submit a project is another chance to win the grand prize. The grand prize is $250 cash plus a Xojo Pro license and a year of GraffitiSuite and will be announce in December. Learn more about the prizes.

The Idea

Early each month we will share a blog post that introduces an app “theme” and recaps the prior month. A week or so later, we will create a Forum topic and post an example project created by one of the Xojo team. To participate in the Year of Code, make a Xojo project that that demonstrates the theme in some way, share it on GitHub to make it easily accessible to everyone and then add a post about it (with your GitHub link) to the Forum topic.

If you have not used GitHub before, here is a blog post on how to share a Xojo project on GitHub.

Ideally, these will be small, focused apps that can be made in a few days. The idea is to have fun creating something that others might learn from. But I guarantee you’ll learn something as well. After all, the best way to get better at coding is to always be coding.

How To Participate

Each month Xojo will announce a new theme and share an example project. Share your own projects in the Xojo Forum thread for that month via GitHub, preferably. Projects with code shared at other sites can be eligible as long as the code is accessible to everyone. Learn how to use Xojo and GitHub.

The Prizes

And yes, there will be prizes for those that participate. Each month all participants (everyone who shares a project that month) will be entered for a chance to win a monthly prize of $100 at the Xojo Store plus a 25% off coupon for GraffitiSuite.¹ The $100 can be applied to any Xojo license purchase or Extras Store item. At the end of 2025, all participants from the year will be entered to win the grand prize of a Xojo Pro license, $250 cash and a free year of GraffitiSuite. The more months in which you participate throughout the year, the more chances you’ll have to win the grand prize.

January’s Theme

Now that it is January (Happy New Year, everyone), the 2025 Year of Code kicks off with this theme: Desktop apps. People have used Xojo to make wonderful desktop apps since its inception in 1998 so this is an ideal first theme that is broad enough to allow anyone to participate. Look for a post next week announcing this months’ project details. Once it is posted, I will start a forum topic for others to share GitHub links to their projects and apps. In early February we will do a blog post that highlights what people made this month and introduce February’s theme.

I hope you will join us for the 2025 Year of Code and I look forward to seeing what you make with Xojo!

#2025YearOfCode

1. Monthly winners are excluded from future monthly prizes but each monthly participant earns an additional entry into the grand prize drawing. ︎

Year of Code Project

• Year of Code: Kickoff
• January Project: Desktop Apps | Forum Discussion
• February Project: Database Apps | Forum Discussion
• March Project: Web Apps | Forum Discussion
• April Project: User Interface | Forum Discussion
• May Project: Mobile Apps | Forum Discussion
• June Project: Code Sharing | Forum Discussion
• July Project: Charting | Forum Discussion
• August Project: Console Apps | Forum Discussion
• September Project: Games | Forum Discussion
• October Project: Multi-Platform | Forum Discussion
• November Project: PDF | Forum Discussion

How to Play:

Each month we’ll announce a new theme and share an example project of our own. Share your projects to the Xojo Forum thread for that month via GitHub (all the links you need are posted above ↑ ). Learn how to use Xojo and GitHub.

The Prizes:

Monthly winners get $100 at the Xojo store. Every month you submit a project is another chance to win the grand prize. The grand prize is $250 cash plus a Xojo Pro license and a year of GraffitiSuite and will be announce in December. Learn more about the prizes.

Community and Resources

In order to succeed with Xojo whether you are an existing user or a new user, you need great resources. In 2024 there have been over 95 new posts on the blog. The latest addition to the Xojo team, Gabriel Ludosanu, has written some wonderful tutorials and explainers on the blog that can quickly get you up to speed with many useful Xojo features.

Speaking of Gabriel, he’s also been enhancing our YouTube channel with Shorts, which are short-form videos (in portrait-style) that quickly introduce or highlight topics.

For our many new users, the Xojo Textbook and Teacher’s Guide have been updated. In addition, we do our best to support Xojo for students, such as with the GitHub Student Developer Pack.

In the spring we made a change to Xojo Lite to allow it to use the text project file format, making it easier to share your projects using services such as GitHub. We also made Xojo for Linux available for free to better match the ethos of that platform.

We are pleased to share that 2024 was a year of tremendous growth in the Xojo community as our GitHub Student Developer Pack and changes to Xojo Lite have helped drive more new users to Xojo than we’ve seen in years!

New users help drive growth in Xojo, but its lifeblood is our dedicated user base. With four releases in 2024, we continue to improve and make Xojo better for everyone. One thing we’ve been working on for each release is ensuring there are blog posts highlighting major new features, often written by the engineer that worked on the feature.

And of course don’t forget about our long-standing resources such as the Xojo forum, YouTube channel, documentation and example projects all of which get new information through each year.

With all that said, another valuable part of the community is the Xojo MVPs. These dedicated Xojo users help us by providing design feedback, testing of new features while they are in early development and general advice. They truly do help point Xojo in the right direction!

New Features and Improvements

We introduced many shiny new features in 2024 but we also hit the bugs hard. We fixed 16% more bugs this year compared to 2023. We fixed 224% more “old” bugs (that’s bugs that are 2 or more years old) compared to 2023. Overall, we fixed over 900 bugs, closing more bugs in 2024 than were created. We have to give a special shout-out to Robin for his work with the Issues queue. He helps ensure we have reproducible projects for bugs, which makes fixing them much more realistic.

But it’s not just all bug smashing, of course. Here are some of the other great things we’ve worked on throughout 2024.

Let’s start with some things that are not actually part of a specific Xojo release. There have been several robust example projects that we’ve produced to help you use Xojo in fun and exciting new ways. Some include:

• In Using ChatGPT, Geoff shows you how to connect to the ChatGPT API.
• Log4Xojo by Gabriel adds some slick app logging features.
• Android Design Extensions by Xojo MVP Martin adds “910+ UI extensions for Xojo Android framework”.
• DBKit, although not new in 2024, has been continually improved by Geoff, our intrepid founder and CEO.

Moving on to new features, perhaps one of the biggest announcements was the addition of preemptive threads, spearheaded by William with lots of feedback and testing from Xojo MVP Kem. Preemptive threads allow Xojo apps to even more easily take advantage of the multiple CPU cores that are prevalent on today’s computers and devices, resulting in speed improvements that can be orders of magnitude better than using standard threads. William also added the highly useful ZIP capabilities, recently got XojoScript working with ARM on Windows, has improved the debugger and exposed our SSLSocket TLSv1.3 support.

Ricardo has been doing tremendous work on the web framework, making it much faster and adding new features such as Popovers, CSS classes, simplified & faster WebDataSource and Named Colors (Ricardo’s fav!). If you haven’t looked at Xojo Web in a while, you might want to take another peek.

We also did a major upgrade to Xojo Cloud’s Linux backend that kept Travis busy for a while.

Javier has led improvements in the Xojo framework and iOS, adding long-requested features such as Popovers and Barcodes/QR codes. In addition, iOS can now use the privacy manifest. Speaking of Javier, he also improved macOS app distribution with Sandboxing, Hardened Runtime and Notarization, one of your top feature requests. Charting and PDF have also continued to improve under Javier’s watchful eye.

Android has been getting lots of fixes and new features in 2024 with Paul adding such things as tablet support, localization, better Declare capabilities, TCPSocket, RegEx, ByRef and much more. When not working on Android, he’s also spent some time on the Code Editor by improving autocomplete and adding new capabilities such as row highlighting, syntax help area size settings, easier standardize format and selection matching.

Behind the Scenes

Although not as publicly visible, Jason (or JSON as we call him around here), handles the bulk of technical questions that come in through customer support. The personal touch and assistance customers get from him is often lauded by them as something you don’t see from other companies.

You may not have noticed many mentions of Travis above, but he’s been hard at work in Xojo’s kitchen, cooking up things you’ll likely see in 2025.

Matt and Geoff work diligently to keep the docs updated with Xojo’s many changes and improvements.

(This bit is from Paul, since Alyssa won’t write about herself.) Lastly, Xojo wouldn’t exist without Alyssa keeping things operational. From dealing with general customer support issues to social media, licensing, marketing, accounting and even more I can’t think of, Alyssa is the glue that holds Xojo together. The rest of us nerdy introverts really appreciate everything she does.

Thank You

This is all made possible because of the one-of-a-kind, amazing Xojo community. To those of you who have supported Xojo through the years, and to the new users out there finding and enjoying Xojo, we thank you! We wish everyone a lovely holiday season and we look forward to seeing you in 2025!

The Xojo Team

Geoff, Jason, William, Alyssa, Robin, Paul, Travis, Javier, Ricardo, Matt & Gabriel

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Like 4D, Xojo has a drag and drop user interface builder, a Code Editor, a Debugger and a Compiler as well as a cross-platform framework. While 4D now has an object-oriented language as an option, Xojo has always been object-oriented. The language is a dot syntax not unlike Javascript. You do not have to become an experienced object-oriented programmer to use Xojo. One of its strengths is that you can learn incrementally.

Xojo supports database application development but there are differences between how it and 4D handles that. 4D has its own database engine and query syntax. Xojo supports SQLite, PostgreSQL, MySQL and ODBC for accessing databases. Unsurprisingly it uses SQL as its query syntax. Because 4D is solely designed for database application development, it ties the user interface you create to tables in the database. Xojo does not. 4D’s model prevents you from having to write code to get data from database records in and out of your user interface. While by default Xojo does not provide this, it provides an add-on called DBKit which assists you in connecting to and interacting with databases.

Xojo supports desktop development for Linux, macOS, Windows and Raspberry Pi (Linux on ARM). It supports web development as well and mobile development for iOS and Android. You can also build console apps which can be handy when you need an app with no user interface to run on a server. Xojo uses native controls and compiles to native machine code for x86 and ARM. Whether you come to Xojo to build desktop, web or mobile apps, you’ll find that 95% of what you learn and the code you write will be applicable to all targets. With the exception of iOS (which because of Apple’s requirements must be built from a Mac) you can build your apps from any platform to any platform. Xojo also includes a Remote Debugger which allows you to build from one operating system and run on another. For example, you might do your development on macOS but want to debug on Windows to track down a Windows-specific issue. With the Remote Debugger, this is quite easy.

Xojo is free to use for development. You only purchase a license when you need to deploy. This is a developer license, not a deployment license. That means that you can deploy as many applications as you like to as many users as you like, without any additional cost. Each developer purchases their own license. A Xojo license comes with 12 months of updates. The new Xojo releases available during your license period continue to be available to you even after your license expires. Renewing your license gets you another 12 months of updates. If you only need to deploy cross-platform desktop applications, the Xojo Desktop license is $399USD. Yearly updates are also $399USD. If you wish to build for any platform we support, the Pro license is $799USD. Yearly updates are also $799USD. Compare licenses and find more pricing details at our webstore.

If you’d like to give Xojo a spin, I recommend starting with the QuickStart and then the full tutorial. After that, check out DBKit, the video and its tutorial which will make it easier to build database-oriented applications. These are the desktop tutorials but there are also tutorials for mobile and web application development. Because Xojo is a general, cross-platform development tool rather than one specifically for database applications, what you build with it is truly limited only by your imagination. If you have any further questions, please reach out to us. Our user forum is also filled with experienced and enthusiastic Xojo users that answer and have answered hundreds of questions. And the Xojo Blog has many posts on database development with Xojo.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

• Structures
• ByRef parameters
• Operator_Lookup
• Operator_Convert

Structures

Structures are a fixed-size data structure that can contain properties of simple types, such as Integer, String or Boolean.

Normally you would only use Structures with Declare API calls, but they can also work as a lightweight, project item specific data structure.

For Android, Structures are not fixed-sized data structures and are not appropriate for Declares, but they offer slightly more flexibility, especially with regard to Strings. When you add a String to an Android Structure, the specified size is ignored; you can store any size string in the property.

Usage is the same. Create a Structure in the Structure editor for the project item, adding the properties you want.

Note that the Offset and Size columns are not relevant in Android since the Structure is not fixed-size.

In code, you create a structure by name:

Var st As StructTest
st.Age = 42
st.Dead = True
st.Name = "Bob Roberts"
st.Weight = 200.6

Since Android Structures are not size-based, the ByteValue, Size and StringValue members are not useful and will raise an UnsupportedOperationException when used.

ByRef Parameters

ByRef parameters allow you to pass a parameter “by reference” so that the caller can access its new value if it was changed. By default, parameters are passed ByVal (or “by value”) so that the caller does not see any changes made to them in the method.

Use the ByRef keyword in front of the parameter to make it ByRef.

The ByRef page in the docs has more information.

Operator_Lookup

Operator_Lookup might be unique to Xojo. When you add an Operator_Lookup method to a class, it essentially tells the compiler to not do a syntax check on method or property names. Instead, if the name that follows the “.” is not an actual member of the class, then the name is passed as a string parameter to the Operator_Convert method.

You can do some strange things with Operator_Lookup, including making your code much more difficult to debug. Use this advanced feature wisely.

Learn more about Operator_Lookup in the docs.

Operator_Convert

Operator_Convert is used with classes to allow them to either construct a new instance from a value of a different type or to allow them to return a version of itself that is compatible with the destination type.

Here is an example of a Person class that uses Operator_Lookup. The Person class has a property: FullName As String. This is how you might normally create an instance and assign a value to FullName:

// Person is a class with a property FullName As String
Var p1 As New Person
p1.FullName = "Bob Roberts"

Now add an Operator_Convert method to the class like this:

Sub Operator_Convert(name As String)
  Self.FullName = name
End Sub

With that method, you can now assign a string value to a Person variable and it will create an instance and assign the string value to the FullName property. The syntax looks like this:

Var p As Person
p = "Bob Roberts"

You can also add an Operator_Convert method that returns a representation of a class instance as a different type. For example, say you wanted a Person instance to be able to convert itself to a string. First you have to decide what the string would be and in this case it makes sense to use FullName.

Here is that Operator_Convert for Person:

Function Operator_Convert As String
  Return Self.FullName
End Function

This code then assigns a Person instance to a Label’s text property where it gets assigned what is in the FullName property:

Var p2 As New Person
p2.FullName = "Janet Jane"
Label1.Text = p2

Like with Operator_Lookup, Operator_Convert is an advanced feature. Use it carefully. It certainly allows for some code to be simplified, but it also means that code might not be as clear as it would if it used more standard syntax.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Using a WebPopupMenu with a Keyboard

2024r4 comes with keyboard full support for WebPopupMenu. We’ve been gradually improving this control to allow your users to select a field using the arrow keys, for example. What’s new is being able to go directly to one of the item just by starting to type its name.

Memory Usage Improvements

Everyone does their best to avoid leaking memory but, sometimes, that’s just not enough.

Jérémie Leroy is known for the success of the mobile apps he makes with Xojo. When one of these successful app requires a Web Service, receiving 1000s of requests, it needs to be as lightweight as possible.

Thanks to his reports, the visual controls will be creating Tooltip and WebCSSClasses instances only when being used. For many projects this won’t make a difference, but having a Web project with hundreds of concurrent users will surely lead to less memory pressure, allowing to run Web apps in cheaper servers.

This task never ends. Upcoming releases will continue improving memory usage and performance.

WebMapViewer

The library we use to display maps, MapLibre, has been upgraded from 3.2.0 to 4.7.1, which will make much easier to implement some of the features we want to introduce in upcoming releases. Stay tuned!

This control also received 4 additional bug fixes. One of them was causing the Zoom to be modified, when updating another control property, for example.

Some New Features

While Web received mostly bug fixes this time, it also comes with some hidden gems.

Popover position can be adjusted now when displaying it. The positioning is relative to its parent control. Additionally, you can now use a WebPage as the parent control, instead of one of the page children, to place your Popover exactly where you need.

Last, but not least, my favorite new feature. We’ve added CallLater method to WebTimer. It works exactly the same as Timer.CallLater, but it’s Session aware. This means you will be able to access the Session from its callback, without having to do anything special.

Wrapping Up

We are saying goodbye to a 2024 packed with improvements for the Web target, with a release dedicated (more than usual) to bug fixing and to make everything more stable. Make sure to check Xojo 2024r4 Release Notes, so you don’t miss anything.

Thanks to everyone reporting bugs, making feature requests and collaborating in the forum!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

What’s New in Xojo 2024r4

Xojo 2024r4 brings a range of exciting updates that enhance cross-platform development, improve security, and provide more tools for creating dynamic and interactive applications. Here are some of the standout features:

Web Framework
Enjoy smoother and more efficient web applications with updates to Xojo’s Web Framework. Improved memory usage and numerous bug fixes ensure that your web apps run reliably and perform optimally, providing a better experience for your users.

Discover Web Framework Improvements

These updates and enhancements are designed to make your development process more efficient, productive, and enjoyable. Whether you’re building new applications or enhancing existing ones, Xojo 2024r4 provides the tools and capabilities you need to succeed.

Get Started

To learn more about Xojo 2024 Release 4 and begin your development journey, please visit the Xojo 2024r4 Release Notes. The update is available for download now from the Xojo downloads page.

What’s Next?

We’re continuously working on new features, updates, and enhancements to our platform. If you have any suggestions or ideas, please add them to the Xojo tracker. We’re always looking to improve and expand Xojo to better serve our community.

Thank you for being part of the Xojo community. We’re excited to see what you create with Xojo 2024r4!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Dr. Tratt creates this unnamed language using Python and I thought it might be fun to quickly port it over to Xojo. Before we look at the Xojo version, here’s a brief summary of the language, which is about as stripped down as can be.

First, to simplify things it uses RPN (Reverse Polish Notation, aka postfix) for the expressions. If you’re not familiar with this, it is a different way of writing an expression where the operator comes after the operands. For example you would normally (using infix notation) write an expression to add two numbers like this:

2 + 4

In RPN you would write it like this:

2 4 +

It looks a little odd, but it is much easier to write the code for this, primarily because it removes the need for parentheses and order of operations.

The syntax for this simple language only supports a few things:

• Integer literal values
• +, *, – math operators
• variable assignment
• >= comparison operator
• while…end loop

Lastly, this little language also has no error checking and its only output is the contents of any variables.

With all that said, it does run the program demonstrated in the video, which calculates the factorial of a number:

n = 5
r = 1
while n 1 >=
  r = r n *
  n = n 1 -
end

I call the Xojo version PLX and here it is showing the result of running the above program to calculate the factorial of 5:

The RPN certainly makes that code look odd! Few languages today use RPN for this reason, although it was used by some older HP calculators and the Forth programming language.

The Xojo port primarily matches the Python version since the two languages are not that dissimilar. However the code makes heavy use of the split command to do rudimentary parsing and Python does have a version of split that returns a maximum number of splits or a split that discards empty items. In the Util module is are Xojo versions of these as extension methods of String.

I also took the liberty of using longer variable names in the Xojo code. I’ve found academics like to use too-short names for things, perhaps because of their math background or maybe they don’t type well. Either way, it can make sample code harder to read in my opinion.

The Evaluator class contains the “language” and it has two methods: Evaluate and EvaluateExpression. There is also one property, Variables, that contains the list of variables and their values.

The Evaluate method parses things and calls EvaluateExpression when needed:

Public Function Evaluate(source As String) As JSONItem
  Variables = New JSONItem
  source = source.ReplaceLineEndings(EndOfLine)
  Var lines() As String = source.Split(EndOfLine, True)
  Var programCounter As Integer = 0
  
  While programCounter < lines.Count
    Var line As String = lines(programCounter).Trim
    Var parts() As String = line.Split(" ", 1)
    Select Case parts(0)
    Case "while"
      parts = line.Split(" ", 1)
      If EvaluateExpression(parts(1)) = 1 Then
        // The conditon was true, so process the code in the loop.
        programCounter = programCounter + 1
      Else
        // The condition was false, so search ahead for the "end", skipping the loop.
        parts = lines(programCounter).Split(" ", 1)
        While parts(0) <> "end"
          programCounter = programCounter + 1
          parts = lines(programCounter).Split(" ", 1)
        Wend
        programCounter = programCounter + 1
      End If
    Case "end"
      // Search back for the while to evaluate its expression again.
      parts = lines(programCounter).Split(" ", 1)
      While parts(0) <> "while"
        programCounter = programCounter - 1
        parts = lines(programCounter).Split(" ", 1)
      Wend
    Else
      // Variable assignment and expression.
      parts = line.Split(" ", 2)
      
      Var name As String = parts(0)
      Var expr As String = parts(2)
      
      Variables.Value(name) = EvaluateExpression(expr)
      
      programCounter = programCounter + 1
    End Select
  Wend
  
  Return Variables
End Function

EvaluateExpression handles the operators and operands in expressions:

Public Function EvaluateExpression(expr As String) As Integer
  Var tokens() As String = expr.Split
  Var stack() As Integer
  
  For Each token As String In tokens
    If IsNumeric(token) Then
      // Push the literal value on the stack.
      stack.Add(Integer.FromString(token))
    ElseIf Variables.HasKey(token) Then
      // This is a variable so push its value on the stack.
      stack.Add(Variables.Value(token).IntegerValue)
    Else
      // Process various operators using what is on the stack.
      Var rhs As Integer = stack.Pop
      Var lhs As Integer = stack.Pop
      
      If token = "+" Then
        stack.Add(lhs + rhs)
      ElseIf token = "*" Then
        stack.Add(lhs * rhs)
      ElseIf token = "-" Then
        stack.Add(lhs - rhs)
      ElseIf token = ">=" Then
        If lhs >= rhs Then
          stack.Add(1)
        Else
          stack.Add(0)
        End If
      End If
    End If
  Next
  
  Return stack(0)
End Function

I do encourage you to watch the video so you get Dr. Tratt’s full explanations. He walks through building this up in pieces, whereas I am only showing the final version here.

Download PLX.

Play around with the source, perhaps extending it with your own commands.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

My answer was, of course, “Let me have a look and get back to you.”

I went to my favourite dev tool, Xojo, and went through the process of developing a solution. The connection is a REST API, so I’ll start with a web project and use the HandleURL event. And I’ll use a URLConnection to pass on the request.  Wait … could it be that simple?

Function HandleURL(request As WebRequest, response As WebResponse) Handles HandleURL as Boolean

  // Create the outbound connection
  Var connector As New URLConnection
 
  // Copy the content of the request
  connector.SetRequestContent(request.Body, request.MIMEType)

  // Send the request
  Var result As String
  Try
    result = connector.SendSync("POST", kAddress + request.Path)
  Catch err As RuntimeException
    // Catch DNS, Certificate & Timeout errors
    response.Status = 500
    response.Write(err.Message)
    Return True
  End

  // Return the result of the request
  response.Status = connector.HTTPStatusCode
  response.Write(result)

  Return True

End Function

The answer is, “Yes!”  This is all the code in the entire project.

You will notice that there is no security, but in this instance that is fine as the virtual machine is running this is on the same network as the client server and the firewall is configured to only allow connections from that server.

After processing over 60 thousand requests, memory use is 7.3MB and never exceeded 13MB. CPU usage was at the maximum 1.5%.

Even after using Xojo for 20 years this still blows my mind.

Wayne Golding has been a Xojo developer since 2005 and is a Xojo MVP. He operates the IT Company Axis Direct Ltd which primarily develops applications using Xojo that integrate with Xero www.xero.com. Wayne’s hobby is robotics where he uses Xojo to build applications for his Raspberry Pi, often implementing IoT for remote control.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

For more detailed information, you can refer to the official Xojo documentation on Variants.

What are Variants?

A Variant in Xojo is a data type that can store any type of data. This means that a variable of type Variant can take on different data types without needing to be explicitly converted. This can be very useful when you want to be flexible, but it can also lead to unexpected problems if not handled correctly.

Basic Example

Var dynamicValue As Variant

dynamicValue = 42                              // Integer
dynamicValue = "Hello"                         // String
dynamicValue = 3.14                            // Double
dynamicValue = True                            // Boolean
dynamicValue = Color.RGB(255, 0, 0)            // Color
dynamicValue = New Dictionary("key" : "value") // Dictionary

In the example above, you can see that dynamicValue can take on different data types without the need to explicitly change the type.

Implicit Conversions

Implicit Conversions are automatic type conversions performed by Xojo when using Variants. This means that Xojo tries to interpret the data in a Variant so that it fits the context in which it is used.

Example of an Implicit Conversion

Var dynamicValue As Variant = "123"

Var myInteger As Integer
myInteger = dynamicValue  // Implicit conversion from String to Integer

In this example, the string “123” is automatically converted to an integer when assigned to the integer variable myInteger.

Another Example with Data Types

Var dynamicValue As Variant = "3.14159"

Var myDouble As Double
myDouble = dynamicValue  // Implicit conversion from String to Double

Here, the string “3.14159” is automatically converted to a double. This demonstrates the flexibility of Variants and Xojo’s ability to handle different data types.

Conversion of Floating-Point Numbers

In Xojo, assigning a floating-point number to a Variant will always produce a Double. However, there are other floating-point data types such as Single, Currency, and CGFloat.

Var dynamicValue As Variant = 3.14

Var myDouble As Double
Var mySingle As Single
Var myCurrency As Currency
Var myCGFloat As CGFloat

myDouble = dynamicValue   // Double: 3.14
mySingle = dynamicValue   // Single 3.14 (implicitly converted)
myCurrency = dynamicValue // Currency: 3.14 (implicitly converted)
myCGFloat = dynamicValue  // CGFloat: 3.14 (implicitly converted)

In this example, you can see that assigning dynamicValue (which contains a floating-point number) to different floating-point data types always works, with the implicit conversion performed by Xojo.

Advantages of Implicit Conversions

Flexibility

The biggest advantage of Variants is their flexibility. You can write functions that can work with different data types without requiring explicit type conversion.

Example of a Flexible Function

Function AddValues(value1 As Variant, value2 As Variant) As Variant
  Return value1 + value2
End Function

// Using the function with different data types
Var result As Variant
result = AddValues(10, 20)             // Integer addition
result = AddValues("Hello", " World")  // String concatenation
result = AddValues(3.14, 2.71)         // Double addition

This function can work with integers, strings, and doubles without requiring changes to the code.

Rapid Prototyping

During rapid prototyping, Variants can be useful because they reduce the need to worry about type conversions.

Example of a Quick Prototype

Var quickData As Variant = "42"

If quickData > 10 Then
  MessageBox("Greater than 10")
End If

In this example, the string “42” is automatically converted to an integer to perform the comparison.

Disadvantages of Implicit Conversions

Debugging

It can be difficult to debug errors caused by incorrect type conversions. Since the conversion happens automatically, it is sometimes not obvious why a particular error occurs.

Performance Issues

Implicit conversions can lead to performance issues, especially when large amounts of data need to be converted.

Example of Performance Issues

Var dynamicValue As Variant = "9999999999"
Var myDouble As Double

For i As Integer = 1 To 1000000
  myDouble = dynamicValue  // Performance hit due to repeated conversions
Next

In this example, the conversion is performed during each iteration of the loop, which can impact performance.

Loss of Type Safety

Another risk is the loss of type safety, which can lead to unexpected runtime errors.

Type Property

The Type property is a useful tool to determine the data type of a Variant value. This property returns an integer that corresponds to the type of the value. This can be helpful to ensure that you are handling the correct data type.

Example of Using the Type Property

Var dynamicValue As Variant = "Hello"

Select Case dynamicValue.Type
Case Variant.TypeString
  MessageBox("The variant is a String.")
Case Variant.TypeInt32, _
     Variant.TypeInt64
  MessageBox("The variant is an Integer.")
Case Variant.TypeDouble
  MessageBox("The variant is a Double.")
Case Variant.TypeBoolean
  MessageBox("The variant is a Boolean.")
Else
  MessageBox("The variant is of another type.")
End Select

In this example, dynamicValue.Type is used to determine the type of the Variant value and perform corresponding actions.

When Should You Use Variants?

Suitable Use Cases

Generic Functions

If you are writing functions that need to work with different data types, Variants can be very useful.

Function CompareValues(value1 As Variant, value2 As Variant) As Boolean
  Return value1 = value2
End Function

// Using the function with different data types
Var isEqual As Boolean
isEqual = CompareValues(10, 10)          // True
isEqual = CompareValues("Hello", "Hello")  // True
isEqual = CompareValues(3.14, 2.71)      // False

Interoperability with External APIs

When working with APIs or interfaces that return different data types, Variants can provide an easy way to handle this data.

// Example API response that can return different data types
Function GetApiResponse() As Variant
  // Simulated API response
  Return "42"  // Could also be an Integer or a JSON object
End Function

Var apiResponse As Variant = GetApiResponse

If apiResponse.Type = Variant.TypeString Then
  MessageBox("Response is a string: " + apiResponse)
ElseIf apiResponse.Type = Variant.TypeInt32 Or _
       apiResponse.Type = Variant.TypeInt64 Then
  MessageBox("Response is an integer: " + apiResponse)
End If

Data Structures

In situations where you need data structures that contain different data types (e.g., an array that can contain both strings and numbers), Variants are a good choice.

Var dataList() As Variant
dataList.Add("Xojo")
dataList.Add(2024)
dataList.Add(True)

// Accessing different data types in the array
For Each item As Variant In dataList
  Select Case item.Type
  Case Variant.TypeString
    MessageBox("String: " + item) 
  Case Variant.TypeInt32, _
       Variant.TypeInt64
    MessageBox("Integer: " + item) 
  Case Variant.TypeBoolean
    MessageBox("Boolean: " + item)
  End Select
Next

Situations to Avoid Using Variants

Performance-Critical Applications

When performance is critical, you should avoid Variants because automatic type conversion introduces additional overhead.

Var dynamicValue As Variant = "9999999999"
Var myDouble As Double

For i As Integer = 1 To 1000000
  myDouble = dynamicValue  // Performance hit due to repeated conversions
Next

Code Clarity and Maintainability

When code readability and maintainability are paramount, you should use explicit data types to ensure that the code is understandable to other developers.

Var myString As String = "Hello"
Var myInteger As Integer = 123

Function ConcatenateStrings(s1 As String, s2 As String) As String
  Return s1 + s2
End Function

Var result As String
result = ConcatenateStrings(myString, myInteger.ToString)  // Clear and understandable

The use of Variants in Xojo offers both advantages and disadvantages. While flexibility and rapid prototyping capabilities are compelling arguments, you should be aware of the potential problems that can arise from implicit conversions. Variants are best suited for scenarios where flexibility and generic programming are required. In performance-critical applications or projects that require high maintainability, it is advisable to use explicit data types such as String, Integer, Double, Boolean, Color etc. or, if you decide to use Variant, you can also have the explicit data type of the Variant delivered. To do this, use the Variant …Value properties (for example StringValue, IntegerValue, BooleanValue etc.).

By taking a conscious and deliberate approach to using Variants, you can leverage their advantages while avoiding potential pitfalls.

For more detailed information, you can refer to the official Xojo documentation on https://documentation.xojo.com/api/data_types/variant.html.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube