Paul Lefebvre – Xojo Programming Blog

Jade Improvements

Paul Lefebvre — Tue, 31 Mar 2026 15:23:00 +0000

For Xojo 2026 Release 1, we’ve made some improvements to Jade, Xojo’s integrated AI assistant. Jade is easily accessible from the toolbar, making it handy for getting coding advice and asking general Xojo questions, especially about the documentation.

In this release, Jade’s output has been improved to limit scrolling when responses are shown, making it easier to read through the specific information and code samples. In addition, Jade now does a better job of parsing the results it gets, which prevents situations where responses could sometimes get cut off.

Lastly, Jade has had some fixes to improve reliability and has been updated to use Anthropic Claude Sonnet 4.6 for more detailed and accurate responses.

These improvements may be small, but they allow Jade to continue to be a helpful Xojo coding assistant.

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.

More New Features for Android: MobileChart, MobileColorPicker, MobilePDFViewer & Zip/Unzip

Paul Lefebvre — Tue, 31 Mar 2026 15:22:00 +0000

The first release of 2026 brings some notable new features to Xojo’s Android support. You’ll find new charting, color-picking, PDF viewing, and file-zip utilities, plus ongoing improvements to several controls. Here’s a quick tour of what’s new.

MobileChart

Matching the features available for iOS, MobileChart lets you create a wide variety of charts to show in your Android app.

MobileColorPicker

This new control, as its name suggests, lets you use the system color picker to select a color.

MobilePDFViewer

Last year Android added PDFDocument support for creating your own PDFs, and now we’ve added MobilePDFViewer to give you an easy way to show PDF document files from your Android apps.

Zip/Unzip

The FolderItem class now supports the Zip and Unzip methods to make it simple to compress and uncompressed Zip files.

Android Keeps Getting Better

There are also improvements to MobileTabPanel, MobileTextArea, MobileSlider, MobileScrollableArea, Barcode and more. With each release, Android gets closer to feature parity with iOS!

And of course, we continue to squash framework and compiler bugs.

Be sure to check out the full release notes for all the details!

Introducing Jade, the Xojo AI Assistant

Paul Lefebvre — Tue, 09 Dec 2025 16:31:26 +0000

With Xojo 2025 Release 3, we are introducing Jade, an AI assistant for Xojo. This initial version is primarily for asking general Xojo-related questions and can be used as an alternative to the documentation.

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.

Checking Out Xojo Libraries

Paul Lefebvre — Tue, 09 Dec 2025 16:29:31 +0000

The ability to create a compiled Library with Xojo has been a long-requested feature. Starting with 2025 Release 3, Library support is now available as a preview. Here’s more information about what it is and how you can use it.

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:

In a Desktop, Web, Console or iOS project add a Library by choosing Insert->Library.
Add the project items you want to the Library. Any Xojo project item is supported, except for Worker.
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).
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:

Microsoft Ends Support for Windows 10

Paul Lefebvre — Wed, 05 Nov 2025 18:51:39 +0000

On October 14, 2025, Windows 10 reached the end of its support from Microsoft. According to their support page:

At this point technical assistance, feature updates and security updates is no longer provided.

Released in July 2015, Windows 10 had a good run. It was well-received and served many millions of people well. When it was introduced, Microsoft said that Windows 10 would be the “last version of Windows“, but given where we are now that clearly did not end up being true.

If your development machine is still running Windows 10, you really need to get it upgraded to Windows 11. Unfortunately, many perfectly usable computers running Windows 10 do not meet the system requirements for Windows 11, which leaves a lot of people in the lurch. If you really have to stick with Windows 10 for a while longer, Microsoft will sell you an Extended Security Update for $30. This will extend support one more year, so out to late 2026.

What does this mean for Xojo? Nothing just yet. We still have Windows 10 as a supported OS, but don’t expect that to last much longer. Once an OS vendor drops support for an OS, we have to follow that guidance at some point. Expect Xojo to discontinue Windows 10 support at some point in 2026.

Year of Code 2025: September Project, Games

Paul Lefebvre — Mon, 08 Sep 2025 17:57:38 +0000

I’m a bit of a retro computing and gaming guy and I enjoy making versions of retro games using Xojo. Although Xojo is not really designed for making games, its Canvas class works well for many kinds of simple games. That means our theme for the Year of Code for September is Games!

One of the first games I made using Xojo was a clone of Atari Tank (based on the version included with the Combat Atari 2600 cartridge).

The core of Tank served as the basis for the XojoWars game contest, where it was re-imagined as a space battle.

Tank is a rather simple game and really needs to be two-players, which is why I added the ability for two people to play it over the network using UDPSocket. This version, which I called NetTank, is available on GitLab.

On the mobile side, I’ve made a 2048 sliding-tiles game and Turtle, which I suppose is kind of an infinite version of Frogger.

However, I’ve had the most fun making clones of Asteroids and Space Invaders. I wrote some about Invaders in xDev Magazine last year, but at some point I’ll get it enhanced enough to share in a blog post.

With that lengthy pre-amble I can now share my game for this month’s project, which is a clone of Asteroids that I uncreatively call Space Rocks. Although an older version of this game has been included with the Xojo examples for several years, this is an updated version with some new features:

Smaller ship to better match proportions of the rocks.
Improved ‘heartbeat’ sound.
High Score is saved and restored.
Level increases as you clear all the rocks, which adds even more rocks that also move faster.
Command or Shift key now work for firing missiles.

Yes, 14340 is my high score. So far. I dare you to beat it!

The full project is on GitHub: https://github.com/paullefebvre/SpaceRocks

Keep in mind that you don’t have to make an arcade-style game. Strategy and turn-based games are a lot of fun and also great candidates for Xojo. For reference, take a look at the web-based Cosmic Trader game that Ricardo made last year. A platform-style or maze game might also be interesting. I can’t wait to see (and play) what you make!

Year of Code Project

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.

Get There From Here with the MobileMapViewer for Android

Paul Lefebvre — Tue, 08 Jul 2025 18:01:00 +0000

A new control added to Android for Xojo 2025r2 is MobileMapViewer. This control uses the Google Maps SDK to display mapping data in your apps.

Before you can use MobileMapViewer you will need to have a Google Maps account configured so that you can generate an API Key. Instructions for doing this on available from Google: Google Maps Platform, Get Google Maps API Key.

Google Maps is not free to use. Although there is some free usage available for testing your app, your account does get billed based on usage once the small amount of free testing credits are used up.

When you have your API Key, you can add it to your Xojo project using a new App property. Select App in the Navigator and in the Inspector, put the key in the Google Maps API Key field. Note that the key is not saved with text projects and is instead saved as part of the UI state file that is local to the development machine. This prevents the key from being accidently committed to a source code repository.

With the configuration work out of the way, you can now use the control. Drag a MobileMapViewer from the Library onto a screen. When you run the project you’ll see an interactive map that you can swipe, zoom and move around as you like.

This code shows Fenway Park in Boston:

FenwayLocation = New MapLocation("Fenway Park, Boston, MA USA")
FenwayLocation.Title = "Fenway Park"

MapViewer1.ZoomRadius = 5
MapViewer1.GoToLocation(FenwayLocation) // Center map within radius km

MapViewer1.AddLocation(FenwayLocation) // Drop a pin

The MobileMapVIewer API matches what has already been in use for iOS. You can also use the MapLocation class to track specific locations. Although the overall API matches what has been used for iOS, there is one exception: MapLocation.PointsOfInterest() is not yet implemented. Implementing this requires another Google SDK and API Key (the Places API) and is being reviewed for a future release. We may also consider adding alternative mapping engines as well.

Note: You can’t get there from here is an old Maine saying.

Identify Yourself with UserAuthentication for Android

Paul Lefebvre — Tue, 08 Jul 2025 18:01:00 +0000

Mobile devices typically have a way for the user to identify themself. This can be using a fingerprint sensor, face detection or even with an old-school passcode or password. The UserAuthentication class, now also available for Android, is a great way to do this authentication.

UserAuthentication works similarly to how it is used on iOS. You can drag the control from the Library onto your layout and then implement the AuthenticationSucceeded event.

To request authentication, call the Request() method with a short string asking the reason why you need authentication.

UserAuthentication1.Request("Authorize me, HAL")

Because this is using system-level APIs, you and your app never know the details about the authentication. You will not know the password, passcode or have any specifics about a fingerprint or face. Instead, if the system determines that the authentication was successful, then the AuthenticationSucceeded event is called.

Here’s a quick video of it in action.

Year of Code 2025: May Project, Mobile Apps

Paul Lefebvre — Wed, 07 May 2025 16:00:00 +0000

One of the most common things I love to use my phone for is sharing pictures of my pets with others. We have two cats and a dog: Shawmut, Christofur and Lucy. To be honest, I’m not much a cat person as I find that cats are almost all Richards, constantly causing and getting into trouble. I’m 100% a dog person.

But even though I have my own pets, I do love looking at pet pictures. It’s a simple pleasure, but there’s not much that I find more calming.

Years ago I made a Xojo app (CatsUp) that displayed random cat pictures and it was a lot of fun. And one thing that Xojo excels at is making it fun to create software! That’s what the Year of Code is all about, after all.

Speaking of that, here is the Year of Code topic for May: Mobile Apps.

You can already find CatsUp for iOS and Android included in the Xojo examples, but why stop at just cats? Being a dog guy, I want to see some dogs. All the dogs.

Since I’m not here to start a cats vs. dogs war, I thought, why not both? It turns out I’m not the only one that thinks this as there are actually public web services that serve up pictures of cats and dogs. Web services and mobile apps go together like peanuts butter and chocolate.

The web service for cats that I’ve previously used is called TheCatAPI and is available here: https://thecatapi.com

There is an equivalent dog one called, unsurprisingly, TheDogAPI: https://www.thedogapi.com

For my mobile app this month, I’ve created an all-new app that can show pictures of cats, dogs or both! I call it Pawz.

Pawz app icon

Actually, it’s two apps since I made versions for iOS and Android. Here’s a look:

Pawz on iOS

Pawz on Android

Although they are separate projects, both use basically the same code. In fact there is only about 50 lines of code in each project! The UI itself is just a big ImageViewer that is used to show the picture and several toolbar buttons.

There are three buttons to request a cat picture, dog picture or a surprise picture that could be either. There is also an extra button that lets you share the picture, if you really like it.

You can find the source for the iOS and Android versions of Pawz on GitHub here:

https://github.com/paullefebvre/pawz

Year of Code is all about having some fun making an app. As you can see with Pawz, it doesn’t have to be anything extravagant. Even fun apps can be made quickly with very little code!

I can’t wait to see what great mobile apps you all create this month. Share your creations in the Forum topic.

One More Thing

Although phones and tablets are what we usually think of when talking about Mobile Apps, you know what else is rather mobile? A vehicle! And it just so happens that many vehicle manufacturers, such as Cadillac, Chevy, Ford, Honda, Polestar, Renault and Volvo are now using Android to run their infotainment systems. Technically it’s Android Automotive OS (AAOS), but it is very similar to regular Android.

Because Xojo builds standard Android Runtime (ART) apps, Xojo Android apps also work on Android Automotive OS as a “parked app”. You can test with this by using Android Studio to install an Android Automotive VM for the Emulator. Once you’ve added that you can run your Xojo Android projects on it just like any other device. Pawz works fine in an AAOS Emulator.

Why do I bring this up? No reason, although I believe Xojo 2025 Release 2 pre-release testing might be starting soon…

Year of Code Project

How to Play:

The Prizes:

Android ColorGroup and Improved Dark Mode Support

Paul Lefebvre — Tue, 25 Mar 2025 15:33:35 +0000

Xojo 2025 Release 1 adds support for ColorGroups and improves dark mode support for Android.

ColorGroups

Now available for Android, ColorGroups are a way to have a color that can differ between light mode and dark mode. There are three types of ColorGroups: Single, Dual and Named. Add a ColorGroup to your project using Insert->ColorGroup.

A Single ColorGroup is not really a group, it is just a single color. A Dual ColorGroup has separate colors for light and dark mode. A Named ColorGroup gets the color from the system or, in the case of Android, the app theme. You can see the available options in the Android submenu.

For the most part you can use ColorGroups just like you can with other project types. Android does have one addition, the ColorGroup.ToColor() method lets you specifically convert a ColorGroup to a Color. Normally this is done automatically by Operator_Convert, but support for that in Android is still young and this method serves as a workaround should you run into issues with it.

In the Inspector for controls with ColorGroup properties, such as MobileButton.CaptionColor, you can use the ColorGroup selector to manually choose a Color or a ColorGroup:

In addition to working with ColorGroups as project items, you can also create ColorGroups in code:

Var cg1 As New ColorGroup()
cg1.AddColorPair(ColorGroup.Platforms.Mobile, Color.Blue, Color.Teal)

You can also use Android system color names to create a named color:

Var cg2 As New ColorGroup()
cg1.AddNamedColor(ColorGroup.Platforms.Mobile, "holo_purple")

Refer to the Android docs for R.color to see what the system color names are. Keep in mind that not all names are available on all versions Android OS.

For more about ColorGroups, refer to the documentation.

Dark Mode Support

ColorGroups are particularly useful with dark mode and starting with 2025r1, Android projects now default to having Supports Dark Mode switched on.

Several controls have been improved to work better in dark mode at runtime.

In addition, the Android Layout Editor has been improved to look better when working in dark mode and now shows controls with dark mode variants.

Download the latest Xojo release and get access to these new features and more.

Use AndroidMobileUserControl to Create Custom Controls

Paul Lefebvre — Tue, 25 Mar 2025 15:30:00 +0000

Xojo for Android has robust Declare and Library support that allows you to call into many native Android libraries and frameworks. With the newly added AndroidMobileUserControl you can also create your own native UI controls as well.

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!

Year of Code 2025: February Project, Database Apps

Paul Lefebvre — Tue, 11 Feb 2025 16:48:26 +0000

February’s Year of Code 2025 topic is Databases and my project is a SQLite object-relation mapping library that I call Storm.

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!

Year of Code Project

How to Play:

The Prizes:

Year of Code 2025: January Project, Desktop Apps

Paul Lefebvre — Wed, 15 Jan 2025 19:26:16 +0000

January’s Year of Code 2025 topic is Desktop apps and my project is XojoText.

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

Year of Code Project

How to Play:

The Prizes:

Year of Code 2025: Kickoff

Paul Lefebvre — Thu, 09 Jan 2025 16:30:00 +0000

Xojo is kicking off 2025 with something for everyone in the Xojo community, an event that will help new users grow their Xojo coding skills and existing users polish theirs. Back in 2018, we did a “Summer of Code” contest that challenged people to create one project a week through the summer. This was a lot of fun and many interesting apps were made that summer. For 2025, we have expanded that idea out to the entire year! However, instead of one app a week, we will make one app a month from January to November 2025. In December we will give away a grand prize!

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

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

How to Play:

The Prizes:

Android Localization

Paul Lefebvre — Tue, 10 Dec 2024 16:37:49 +0000

You can now take advantage of Localized Strings in your Android projects to better localize your text. Localized Strings are added to using the Constant Editor using these steps:

Add a Constant, give it a name, default value and set its type to String.
A Localized property will now appear in the Inspector. Turn it on.
This constant will now appear in a new “Localized Strings” section in the Navigator for the project item.
Use the “+” button to add a localized string, then set its Language and Value.
Use this localized string in your project.

Below is a localized string that contains some translations of “thanks”.

The most common way to use this is to specify the localized string name as the text property for a control, such as a Label. You prefix the name with “#” to indicate it should be looked up at runtime.

Below you can see “#ThanksString” is set as the value for the Text property of Label1.

Note that “Default” is shown in the IDE because it is using the value for the “Default” language in the localized string. If there was no “Default” language, then the value specified in the Inspector as the “Default Value” is shown in the IDE.

If we then run this project on a device set to US locale, it displays “Thanks”:

If I change to a German locale and run again, it shows “Danke”:

To change the locale, open Settings on the Android device. Navigate to System and then Languages & input. There you will see the Languages option.

Choose that to see the list of languages supported by the device. Click the “+” to add a language. Here I’ve added German (Deutsch):

To make Deutsch the default, drag it so that it is first in the list. You’ll immediately see the UI change its language.

You can also specifically request a language in code by providing the locale as a parameter to the localized string. For example to get the French value:

Var french As String
french = ThanksString("FR")
// Variable french now contains "Merci".

Read the Introduction to App Localization documentation topic to learn more.

Android Language Features

Paul Lefebvre — Tue, 10 Dec 2024 16:37:38 +0000

Android has been updated to support several standard Xojo language features, including:

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.

Code Editor Selection Matching

Paul Lefebvre — Tue, 10 Dec 2024 16:37:25 +0000

A new feature of the Xojo Code Editor is Selection Matching. When this feature is turned on, selected text is highlighted everywhere it appears in the current Code Editor.

Here you can see that “customerRS” is selected on line 14 and all the other places where it appears in the method is also highlighted.

This feature can be very handy to see how things are used in your code and is much easier than using the Find panel.

Note: The matching is done by full word tokens. So if you highlighted just “customer” in the above code, then nothing is matched because that does not match the “customerRS” tokens.

To turn this feature on, head over to Settings, Coding and check the box for “Display selection matches”.

You can also change the color that is used for the matching by changing the Syntax color “Selection Match Color”.

Creating Your Own Programming Language

Paul Lefebvre — Thu, 21 Nov 2024 17:38:39 +0000

Computerphile is one of my favorite YouTube channels. It’s full of “videos about computers & computer stuff”, usually pretty nerdy things. One of their recent videos is called Creating Your Own Programming Language and it is an interesting watch. In just about 20 minutes, Dr Laurie Tratt (of King’s College London) creates a very simple programming language in just a few lines of code.

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.

Android Tablet Support

Paul Lefebvre — Tue, 01 Oct 2024 15:31:26 +0000

Android apps made with Xojo have always worked on tablets, but until Xojo 2024r3 there has been no easy way to design your screens for tablets. Below are the new features that should make it easier to create Android tablet apps.

Layout Editor

The Layout Editor has been enhanced with two settings that can adjust the layout.

The command bar has two toggle buttons. The first one already existed and it is for displaying the layout in portrait (the default) or landscape.

The new toggle button displays the layout in a phone size (the default) or a tablet size. When you switch between any of these toggles, the locking is applied to the controls on the layout.

The layout editor also remembers the selections so that the next time you visit the layout, it will be where you left it. Here you can see a landscape tablet layout:

Default Screen

The App Inspector has an additional Default Tablet Screen property. When your app is launched on a phone or tablet-sized device, the specified screen is what gets displayed.

You can also choose “None” for a default screen if you just want to share a single screen across both types of devices.

If you choose “None” for the Default Phone Screen, then the app won’t launch on a phone. If you choose “None” for a Default Tablet Screen, the app will launch on the tablet using the Default Phone Screen, which matches prior behavior.

Design Considerations

Xojo for Android uses locking to automatically adjust controls on the layout. Locking will work for certain types of layouts that you want to run on both phones and tablets, but may not be sufficient for more complex layouts. In these situations, you are better served by designing completely separate layouts for phone and tablet and then using the above Default Screen properties to show the correct one.

When you need to show additional screens, you can show the phone or tablet screen in code by checking the device using DeviceData.Orientation and DeviceData.UserInterfaceType.

If System.Device.UserInterfaceType = SystemDeviceData.UserInterfaceTypes.Tablet Then
  // Show tablet screen
  myTabletScreen.Show
Else
  // Show phone screen
  myPhoneScreen.Show
End If

When you have multiple screens, it often makes sense to put the UI in containers and then use the containers on the different screens.

You can run your apps on a Tablet emulator for testing (you can create one using Android Studio) or you can debug directly on device. I enabled on-device debugging for a Lenovo Tab M10 Plus 3rd Gen with these steps:

Go to Settings.
Select About tablet.
Tap 7 times in a row on the build number. This enabled Developer options. You may be prompted to enter your PIN.
Select System and then Developer Options.
Turn on USB debugging and give it permission.

The tablet will now appear as a debug device in Xojo, allowing you to run your Android projects on it.

What about Chromebook?

Some Chromebooks are able to run Android apps and those that can are also able to run Xojo’s Android apps. Android apps can be installed via the Play Store (give CatsUp a try) or manually, although doing it manually is rather difficult (I have not yet gotten that working on my Chromebook). The Play Store options works well, however. Here’s CatsUp from the Play Store running on my Lenovo 300e Chromebook:

When run on the Chromebook, Android apps can have a size of Phone, Tablet or Resizable. You can see that as an option in the title bar of the above screenshot. For best results you probably want to design your apps for a landscape tablet.

Xojo for Android does not have direct support for Chromebook features at this time, but if there is something you’d like to see, be sure to create an Issue so that we can look into it.

Since Chromebooks are just (low-end) Linux machines at their core, they can technically run Xojo Linux apps (x86 or ARM depending on the Chromebook), but this usually requires some sort of additional Linux installation.

And of course, Chromebooks are typically meant to run web apps, which Xojo can also do quite well.

Eddie’s Electronics Example Project

The Android Eddie’s Electronics example project has been updated to run on both phones and tablets. It makes use of Containers to contain the UI and displays them using screens for the appropriate device type.

Here you can see the Customer screen for a tablet displays the list of customers on the left, with details and invoices on the right.

Compare that to the phone version which has you navigate between that information using separate screens.

Tablet supports opens up a whole other category of users for your Android apps and should be particularly useful to those making bespoke apps for clients.

Android Declare and Library Enhancements

Paul Lefebvre — Tue, 01 Oct 2024 15:30:45 +0000

There have been several enhancements to Declare and Kotlin Library support in Xojo 2024 Release 3 which, along with previous improvements, should allow you to interface your Android projects with more from the native ecosystem.

This post describes the things you can do with Declares and Libraries with Android projects.

Declare Integer Types

The size-specific Integer types are now precise when used with Declares. The mappings are as follows:

Xojo Type	Kotlin Type
Int8, Byte	Byte
UInt8	UByte
Int16	Short
UInt16	UShort
Int32	Int
UInt32	UInt
Integer, Int64	Long
UInteger, UInt64	ULong

When mapping to Android API functions or Library functions, be sure to use the correct Xojo type that matches what is expected on Android. By far you will use Int32 and Integer.

If you previously created Declares, you will likely need to change usage of Integer to Int32 as the mapping for that have changed compared to prior versions.

Nullable Types

Xojo object variables (also properties, parameters and return values) can be Nil. With Kotlin, the default is that these things cannot be null (the equivalent of Nil). To ensure that you don’t get compile errors with your parameters, declare them as nullable in Kotlin by appending the “?” to the end of the type name.

Application Context

Many Android APIs require the application context. This is not available in a Library so it has to be supplied by the app itself. There is a property for this:

MobileApplication.AndroidContextHandle As Ptr

You can pass this value to a function on the Library that then either saves it or uses it directly.

Using Ptr

Xojo uses the Ptr type to interface with Declares, however Kotlin does not have a Ptr type. Instead the Any type is used with Kotlin. This means that if you are passing something that is a Ptr to Kotlin (such as the app context above), your library function declaration should use “Any?” as the type of the parameter.

In your function, cast the parameter to the actual type you want. The same rule applies to return values. If the return value in the Declare is a Ptr, then in Kotlin the function declaration should be “Any?”.

You can also use Ptr with API calls to save object references as described below.

Library Permissions

Depending on the API you are using, you may need to add permissions to the app manifest.xml for the Library. These permissions also need to be applied to the main app. This can be done using the Advanced tab of the Android Build Settings. There you’ll find the Permissions property in the Inspector where you can add one Permission per line.

Previous versions let you separate permissions by spaces or commas. Going forward, each permission must be on its own line. Empty lines are ignored.

There you can add the permission constants that are required by your Library. In addition, you can follow the constant with additional attributes and they will also be applied to the app’s manifest file.

For example, to include the android:maxSdkVersion attribute with the BLUETOOTH permission:

android.permission.BLUETOOTH android:maxSdkVersion="30"

Library Dependencies

Similarly to permissions, your Library may make use of additional dependencies, which could even be other Libraries. These are added to the build.gradle file for the Library, but also need to be included in the main app.

You can add these dependencies using the Dependencies property on the Advanced Android Build Settings.

Creating Objects

Previous versions of Xojo only let you call Companion (essentially shared) methods on Library classes. Now you can also work with class instances and call instance methods. This gives you even better control and ability to interface with Android APIs.

To create an object, your Library class should have a factory method on the Companion that returns a new instance. It is clearest to use create() as this method name.

In Xojo you create a Declare to this create() method and call it, saving the result in a Ptr.

Declare Function create Lib "com.example.utility.counter" () As Ptr
Var counter As Ptr = create

Instead of using a shared factory method, you can also call the Class constructor using this syntax:

Declare Function counter Lib "com.example.utility.counter" () As Ptr

Because the function name has the same name as the class itself, this will call the constructor of the class.

When you want to call a method on the instance, you pass the instance as a Ptr. First, Declare to the method adding “.instance” to the library location to indicate you are calling a class instance.

Declare Function increment Lib "com.example.utility.counter.instance" (ref As Ptr) As Integer

Then you can call the method and save its value.

Var count As Integer = increment(counter)

The reference as the Ptr must be the first parameter passed in the Declare. Follow it with other parameters as usual.

You can also call instance methods directly in the Android API in this manner.

Method Callbacks

There are Android APIs that use callbacks to methods that you provide. In Xojo these methods are Delegates and are methods that you supply using AddressOf. It is very important that the signature of this method exactly matches what the callback expects which means you’ll be limited to just the Boolean and Ptr types.

If you want to use an API that uses its own callbacks, you’ll be better served by creating a Library and having the API do the callback to your own Library methods, which you can then call back to your Xojo methods.

You can pass the reference to the Xojo method using AddressOf like this:

Var cb As Ptr = AddressOf TestCallback
Declare Sub xojocallback Lib "com.example.utility.callback" (cb As Ptr)
xojocallback(cb)

The Xojo method can only use parameter types of Boolean and Ptr. It looks like this:

Public Sub TestCallback(b As Boolean, i As Ptr, s As Ptr)

In the Kotlin library you have to cast the incoming parameter to a function reference. This is a two-step process where you verify the function has the correct number of parameters and then you cast it to the specific parameter types. Sample code:

if (cb is Function3<*, *, *, *>) {
    try {
         (cb as Function3).invoke(true, 42, "Hello")
         println("Sent callback to Xojo")
    } catch (e: ClassCastException) {
         println("Casting failed: ${e.message}")
    }
}

The “Function3” indicates a function with 3 parameters (the last “*” indicates the return type), but you can change that as needed using Function1, Function2, etc. You can pass anything back through a Ptr type, but the Xojo code has to convert them using Ptr methods so you should not change the types of the values you send back to be different than what your Xojo code expects.

Object Declares

Object Declares are not new, but for completeness are described here. Essentially an Object Declare uses special syntax to Declare to a UI control.

The typical way to use an Object Declare is by adding an Extends method to a Module. For example, an extension method to allow MobileButton to change its colors could look like this:

SetBackColor(Extends ctrl As MobileButton, c As Color)

The Object Declare looks like this:

Declare Sub setBackgroundColor Lib "Object:ctrl:MobileButton" (myColor As Int32)
setBackgroundColor(c.ToInteger)

Breaking this down, we’re calling the setBackgroundColor function. The Lib denotes this new type of Object declare: an Object, separated by a colon, the Xojo name of the object (in this case, our “ctrl” parameter), followed by another colon, and the Xojo type of the object.

Kotlin Declares

You can use the Android-specific “Kotlin” Declare designation to indicates that what is specified in the Alias section of the Declare should be used as is. This is particularly helpful when you want to cast Ptr values to a specific type for use with OS APIs.

This code gets a ColorStateList object for a Xojo Color value:

Var c As Color = Color.Blue

Declare Function valueOf Lib "android.content.res.ColorStateList:Kotlin" Alias _
"android.content.res.ColorStateList.valueOf(android.graphics.Color.argb(alpha.toInt(), r.toInt(), g.toInt(), b.toInt()))" _
(alpha As Int32, r As Int32, g As Int32, b As Int32) As Ptr

Var csl As Ptr = valueOf(255 - c.Alpha, c.Red, c.Green, c.Blue)

This code can then be used to call setStrokeColor on a MobileButton:

Declare Sub import Lib "android.content.res.ColorStateList:Import" // Imports the ColorStateList class

Declare Sub setStrokeColor Lib "Object:ctrl:MobileDateTimePicker:Kotlin" Alias "setStrokeColor(strokecolor as ColorStateList)" (strokeColor As Ptr)
setStrokeColor(csl)

As you can see, in the Alias is the Kotlin method call that casts the incoming Ptr value to a ColorStateList.

Import

Note the “import” declare in the code snippet above. This is also specific to Android. This Declare indicates that a specific class should be imported so that it can be used for casting purposes. If you left off that import, then the cast to ColorStateList would cause a compile error because ColorStateList would not be known.

You only need to import a specific class once. After you’ve done so it can be referenced by any other Declare, even ones in different methods.

The use of an import Declare is optional and is meant to simply the Kotlin method call code in the Alias. Instead of using import you can specify the full class path in the cast like this:

Declare Sub setStrokeColor Lib "Object:ctrl:MobileDateTimePicker:Kotlin" Alias "setStrokeColor(strokecolor as android.content.res.ColorStateList)" (strokeColor As Ptr)
setStrokeColor(csl)

Handles

Many classes in the framework now have Handle properties (or methods) which you can use with various Declare techniques described above. These include: FolderItem, Font, GraphicsPath, Locale, TimeZone, Graphics, Picture. In addition, the mobile controls have Handle properties that can serve as an alternative for an Object Declare.

Sample Project

You can download the sample project that demonstrates a library and some of the concepts described above. You can use this as a template or starting point for creating your own libraries or Declares.

Sample Utility Library Project

You might also want to take a look at the Android Design Extensions open source project, which has hundreds of Declares that can enhance your Android apps.

References

Xojo Code Editor Changes: Line Highlight, Syntax Help Area and Standardize Format

Paul Lefebvre — Tue, 01 Oct 2024 15:30:29 +0000

The Xojo Code Editor has a few notable changes for Xojo 2024r3 that you might find useful.

Line Highlight

The first change is that the entire line containing the cursor is now highlighted. This makes it much easier to find where your cursor is on large displays and matches behavior that is common in other coding editors, such as BBEdit or Visual Studio Code. This highlight is controlled in Coding Settings:

Here is what he row highlight looks like:

Syntax Help Area

With the enhancement to show method overloads in the Syntax Help area a couple years ago, the area was changed to dynamically resize its contents depending on what is shown there. Although some liked this design there were others that felt that it was distracting to have the Syntax Help Area size change so often.

An improvement made last year altered the syntax help area behavior so that it is only updated when the mouse cursor stops moving for a moment. Because of that change, we are able to introduce the option to have a fixed-size Syntax Help Area.

In the Coding Settings, you can choose: 2, 3, 4, 5, 6 Lines or Resizable. The default is now 3 lines. If more information is shown than will fit in the Syntax Help Area, there is a scrollbar (which you can now actually use since the area won’t update with new information until you stop moving the mouse).

You should also notice improved syntax help in general. The lookup engine is now better able to infer context to show more accurate information. I’m particularly pleased that CType now shows in the Syntax Help Area because I can never remember the order of the parameters!

Standardize Format

A long-standing request (from 2010!) was to have the Standardize Format option available on the Code Editor command bar. Lots of people like their code formatted nicely and Standardize Format is a great way to do that.

Now you can easily click a button on the command bar to quickly format everything in the code editor, instead of first having to Select All and then choose a contextual menu option.

If you really like your code to be formatted automatically, don’t forget you can always turn on “Apply standardize format after ending line” in the Coding Settings.

And don’t forget that you can also create your own script to format your code any way you want. Learn more about this in Custom Code Reformatting in the docs. You might also want to try to this powerful reformatting script.

If you have other suggestions for Code Editor improvements, please be sure to create an Issue. One popular suggestion is to have the text under the cursor be highlighted throughout the code editor (see Issue #74741), which I have started to investigate. Read all about the Xojo Code Editor in the Xojo Docs.

Xojo Cloud: More Than Web App Hosting

Paul Lefebvre — Thu, 15 Aug 2024 22:59:40 +0000

What better way to celebrate 10 years of Xojo Cloud than bragging about all the things it can do! When you think of Xojo Cloud, you might think that it is for hosting Xojo web apps. And that’s true, Xojo Cloud continues to be the best and easiest way to host your Xojo web apps, but Xojo Cloud also offers several useful services for other types of apps.

iOS Notifications

Xojo Cloud can function as an Apple Push Notification system (APNs) for handling iOS push notifications. This works with Xojo and non-Xojo iOS apps. All Xojo Cloud servers are pre-configured to send remote notifications. Unlike many other cloud hosts, there is no extra charge for this feature nor is there any limit as to how many notifications you can send.

To send remote notifications from your iOS app you’ll need to go to the Apple Developer website to do these tasks:

Add the Push Notifications feature to the App ID.
Generate an Apple Push Services certificate.

In Xojo you need to enable the Remote Notifications entitlement for your app in the Capabilities section of the iOS Build Settings Advanced tab.

The final step is to upload your Push Services certificate using the Xojo Cloud control panel.

With super-easy access and no limits for notifications, Xojo Cloud can serve as a great APNs for handling your iOS notification needs.

Database Servers

Most desktop apps use a database of some kind and many are client/server database apps that talk directly to the database server. With Xojo Cloud you can host PostgreSQL or MariaDB/MySQL database servers and connect to them using an SSH tunnel for security purposes.

Setting up a database server on your Xojo Cloud is as easy as checking a box in the control panel.

You can turn on PostgreSQL or MySQL/MariaDB. If your Xojo Cloud server is large enough you could even do both.

If you want to access a database on Xojo Cloud from a desktop app, you will have to enable the SSH Tunnel and then connect to the tunnel from the computer. An SSH tunnel is a secure connection between your computer and another (in this case your Xojo Cloud server) which is used for transmitting data on a specific port. In essence, it creates a private connection through the internet which allows you to see into your server on the other end and connect to a particular service there.

To create a tunnel between a computer and your Xojo Cloud server, you first need to turn on the tunnel capability on your Xojo Cloud server. Go to your control panel and click the “SSH Tunnel” checkbox. You will be presented with a generated username and a password which you will use later for establishing the connection.

On macOS and Linux, you can use a terminal command to access the tunnel (replace username and ipaddress as appropriate; you’ll be prompted for the password).

Use this command to tunnel to PostgreSQL:

ssh -L 5432:localhost:5432 username@ipaddress -N

Use this command to tunnel to MySQL:

ssh -L 3306:localhost:3306 username@ipaddress -N

If you are using Windows, you will need to use an external app such as PuTTY. There are a number of tutorials available on the internet, just put “putty ssh tunnel” into your favorite search engine.

With the tunnel in place you connect to the database as if it were local to the computer. This works with anything, not just Xojo apps.

SFTP

Xojo Cloud offers SFTP (Secure File Transfer Protocol) for file transfer. SFTP is a secure variant of FTP which transmits files over the internet using strong encryption. That way you don’t have to worry about anyone intercepting your username and password or your files as they’re sent to or from your server.

When choosing a client, keep in mind that SFTP is different than FTPS or FTP w/ SSL. They are not interchangeable with one another.

Once you enable SFTP in the Control Panel, you’ll be presented with a dialog showing a generated username and password.

You can now connect using your favorite SFTP client. If you don’t have one, there are a number of free and paid options available including:

ForkLift
Transmit
FileZilla
CyberDuck

Having a place to store files online is always handy and can be useful when needing to share files with others without having to rely on services such as DropBox.

Web Services

OK, a web service is technically a Xojo web app but it is really an API that is meant to be used by other apps, often desktop or mobile apps. Since a web service doesn’t have any actual UI, you don’t really need to learn how to use the majority of the Xojo Web framework.

Instead you basically add code to the App.HandleURL event to route web service API calls to do specific tasks and then return the results, usually as JSON for the client app to handle.

A web service can be a great way to consolidate code that will be used by desktop and mobile apps, for example.

For example, you could create a Web Service that talks to a database server (such as one of the ones available in Xojo Cloud itself). Your Desktop and Mobile apps can use the same web service to work with the database. All your database-specific code lives in the web service and the client apps make requests and display results.

This is a very common design pattern these days and is a necessary one if you want a mobile app to talk to a database server.

If you want to learn more about web services, here’s a fun webinar to check out:

Learn more about Xojo Cloud today. Xojo Cloud servers start at $49/month, custom servers with more RAM, storage, and virtual CPUs are available. The best way to host your Xojo web apps is so much more than just hosting web apps!

House of the Snapdragon: Windows ARM is Coming

Paul Lefebvre — Tue, 13 Aug 2024 19:03:20 +0000

We’ve gotten a requests over the last few months asking about Xojo’s support for Windows on ARM and it seems like some people are not aware that Xojo already can build apps for Windows ARM. In fact, we added support for building Windows ARM apps two years ago in Xojo 2022 Release 2!

Some of you might not have noticed because, until recently, most people didn’t think much about Windows ARM. After all, nearly everyone still runs Windows on x86-64 CPUs. But lately, Windows on ARM is starting to get more traction, both in the press and in the market.

Back in May, Qualcomm announced the Snapdragon Dev Kit for Windows. This is supposed to be a $900 mini PC (about the size of a Mac mini) for developing Windows ARM apps for the Snapdragon X Elite SoC (system on a chip). I say “supposed to be” because although the press release says it was intended to go on sale on June 18, I can only find pre-order pages for it, so it seems to not be available just yet or out-of-stock.

There have been other ARM PCs for Windows in the past, but their performance has always been less than desirable. The new Snapdragon X Elite is supposed to be roughly equivalent to Apple M3 SoCs.

You don’t have to wait for Qualcomm as Copilot+ PCs and laptops with Snapdragon SoCs are starting to appear elsewhere. Lenovo has the ThinkPad T14s Gen 6, which at about $1700 is not exactly a bargain, but is in the ballpark of many Mac laptops. The Yoga Slim 7x is even cheaper starting at just $1200.

But I’m not here to sell Lenovo products. I’m just pointing out that Windows on ARM is becoming a reality, if slowly. That might be starting to change given Intel’s recent troubles with its Raptor Lake CPUs and most recent earnings report, however. Take it with a grain of salt, but Qualcomm is predicting that Windows ARM could reach 50% of Windows PC market within five years.

That sounds astonishing, but change often happens slowly then all at once.

Building for Windows ARM with Xojo

The good news is that with Xojo you are already prepared for this. To build your existing Xojo desktop project for Windows ARM, you just need to change one property in the Windows Build Settings and click Build. There is no step 3.

Xojo can also build Windows apps for x86-64 and x86-32, which pretty much covers all your bases. Not to mention that it can build macOS apps, Linux apps, web apps, iOS apps and Android apps.

And if you already have an Apple Silicon Mac then you don’t even need to purchase a Windows ARM computer. You can run Windows ARM as a virtual machine on a Mac using Parallels or VMware Fusion. You’ll still need to get your own license for Windows 11, however.

Although you can make your own Windows ARM apps with Xojo today, there are a couple temporary limitations to keep in mind. The first one is that XojoScript is not yet available. The other is that Xojo itself is not yet a native Windows ARM app. Both of these are because the Xojo compiler itself is not yet native on Windows ARM. That will change, but for now Xojo itself runs perfectly fine using the Prism x86-64 emulation layer in Windows. In addition you can use the Remote Debugger to test your apps on Windows ARM from another computer.

Will Windows ARM replace Intel like it did for Macs? It seems hard to believe, but the wind seems to be blowing in that direction. To make sure you’re prepared, download Xojo for free today and start creating your own ARM apps!

Android: New Features and Improvements

Paul Lefebvre — Wed, 26 Jun 2024 15:00:00 +0000

First released last summer as a Beta, Xojo’s Android support continues to grow and evolve.

Although still in Beta, there have been many improvements to Android in the last few releases and in this post I’ll highlight a few things that have been added or improved starting with Xojo 2023r4 and through the recently released 2024r2.

Xojo 2023r4

The final release of 2023 had a lot of Android improvements.

You should always read the entire release notes, which have a wealth of details, but here are some highlights of useful new features that were added to Android in 2023r4:

Added System.DismissKeyboard method that can be used to hide the virtual keyboard.
The Ptr type can be used with Declares that call Kotlin Library projects. Other usage of Ptr will result in a compile error.
There is a new constructor on Font that allows you to load a font file from a FolderItem. Easy custom fonts!
The Barcode class can be used to scan a variety of barcodes.
The NewAndroidProject command can be used with IDE scripting to create an Android project.
MobileApplication.UnhandledException event now better captures the user runtime call stack for Stack() and StackFrame().
There were many internal changes to the Android framework to get it to have better compatibility with other platforms.
Improvements to URLConnection data encoding.
Several JSONItem improvements.
The Android compiler toolchain was updated to newer versions.
Added Dependencies property to the Android advanced build settings. This can be used with Declares and Libraries to load any external dependencies they need. Put one dependency per line, an example would be: io.github.bitstorm:tinyzip-core:1.0.0
Improved compatibility with Android 14.
Many framework and compiler fixes.

Xojo 2024r1

The first release of 2024 continued the trend of rapid Android improvements.

MobileApplication.Activated and Deactivating events now work on Android.
Fixes and improves to several parts of the framework, including:
- Introspection
- SQLiteDatabase
- JSONItem
- URLConnection
Many other framework and compiler fixes.

Don’t forgot to review the full release notes!

Xojo 2024r2

The latest Xojo release has plenty of improvements for Android. Some highlights include:

MobileHTMLViewer field focus is now more reliable.
TCPSocket is now available.
Many Graphics properties are now available, including: ShadowBrush, LineCap, LineDash, LineDashOffset, LineJoin, Outline.
Improved some compiler error messages.
Many more framework and compiler fixes.

The full release notes are a fun summertime read.

What’s Next for Android?

As you all know by now, we don’t preannounce when things will appear in Xojo releases. We are continually working on adding features and improving Xojo for Android and when new things are ready, they appear in the next scheduled release. The best way to stay on top of what is going to be released soon is to help us with pre-release testing. Remember, if you have an active Xojo Pro license, you have access to a special pre-release section of the forum. If you have a Xojo Mobile license and woudl like to participate in testing please make a request.

With that said, some of the Android features in development include:

ByRef support
RegEx classes
DatabaseConnection
In-app purchasing support

XojoTalk 039 – Thoughtful and Considered

Paul Lefebvre — Thu, 13 Jun 2024 14:00:00 +0000

Paul talks with John Balestrieri about Photo Tape, John’s new iOS app that is made with Xojo.

Download mp3 or watch on Xojo’s YouTube Channel.

Topics include:

^{Heavy Action by Audionautix is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Artist: http://audionautix.com/}