As we approach the release of X# 3, we’re excited to share some insights into what’s coming next for the X# language and development platform.
While X# 2.24 will mark the final version in the 2.x series—with continued support in the form of critical bug fixes—our focus is now shifting toward modernization and .NET 8+ support. X# 3 is designed to bridge the gap between traditional X# development and the evolving .NET ecosystem.
Let’s take a closer look at the modern .Net features that X# 3 will bring to the table.
SDK-Style Projects and NuGet Runtime
X# 3 will fully support:
-
SDK-style Visual Studio projects — Required for targeting .NET 6, 7, 8 and future versions.
-
NuGet-based runtime distribution — The X# runtime libraries will be available as NuGet packages, with binaries targeting both .NET Framework and .NET 8+.
This makes it much easier to integrate X# into modern CI/CD pipelines and cross-platform development environments.
Language Features Planned for X# 3
The X# compiler is being updated to support a selection of modern C# language features, giving developers access to cleaner syntax, safer code, and improved maintainability.
File-Scoped Namespaces
Reduce indentation and simplify file structure.
Old Syntax
NAMESPACE MyApp.Core
CLASS LOGGER
...
END CLASS
END NAMESPACE
New Syntax
NAMESPACE MyApp.Core
CLASS LOGGER
...
END CLASS
Global Usings
Define common using directives once for the entire project. This can be done in a separate source file, but the new SDK style project format also allows project level properties that declare the global usings for the entire project.
// GlobalUsings.prg
global using System
global using MyApp.Common
You can also define global usings in your project file. The build system will then generate and include a source file with these usings.
<ItemGroup>
<Using Include="System" />
<Using Include="System.Collections.Generic" />
<Using Include="System.Linq" />
</ItemGroup>
Nullable Reference Types (Tentative)
Enable nullability checking at compile-time to prevent runtime NullReferenceExceptions. We are already supporting the ? operator for nullable types.
We will also add the null-forgiving operator (! Postfix operator)
#nullable enable
FUNCTION Test ()
LOCAL p as Person?
p := CreatePerson() // may return null
IF IsValid(p) // This only returns TRUE when p is not null and p:Name is not null
? p!:Name // the Exclamation mark indicates that we want to suppress the warning that p could be null, because we KNOW that this could never happen.
ENDIF
RETURN
FUNCTION IsValid(p as Person?)
RETURN p IS NOT NULL .AND. p:Name is NOT NULL
Pattern Matching Enhancements
More powerful switch expressions and type testing:
Readonly Structs and init Accessors
Better support for immutability in your data types.
Features Under Consideration
Some other .Net features are being evaluated for inclusion in future updates of X# 3:
- Top-level statements
- Record types and with expressions
- Raw string literals
- Async streams
- Default interface methods
- Required members
- List patterns
These may be introduced progressively as the compiler and language infrastructure evolve.
Availability and Licensing
- X# 3 will be available as a compiled, installable version for subscribers only.
- The source code will remain open-source and publicly accessible.
- The X# runtime will also be distributed via NuGet packages.
Get Ready for the Next Generation
X# 3 is more than just an upgrade - it’s a leap forward into the modern .NET ecosystem. Whether you’re maintaining legacy code or building new .NET 8 applications, the upcoming features will make your development faster, safer, and more compatible with industry standards.
Stay tuned for the beta release later this year!
Not currently a subscriber yet? Click here to subscribe and use the promo code "Summer2025" for 25% off.
Hello Robert,
I really looking forward to this release.
But besides new language features it also important to point out what the benefits of .Net 8+ are in comparison to the .Net Framework.
Easier deployment, fewer files, faster execution, better memory management or may be a single exe file (again)?
Will native compilation be possible for example?
And can X# apps run on MacOS or Linux?
Kind regards,
Peter
Peter,
The deployment, speed, memory management and single exe are all part of .Net 8, so Yes.
You can also run the apps on MacOS or Linux (as long as you use features that are not "windows only", like Windows Forms)
Native compilation: I am not sure. We will have to look into this.
Robert
Hello Robert,
Just a follow up. I know all this from the early days of .Net Core (which is already nearly 10 years old and, if I am correct, older than X# itself by the way and version 10 (!) of .Net is about to be released in November).
My question was more about if its worth the effort porting a X# .Net Framework application to .Net Core on Windows. This question should also be addressed in the annoucements or in a white paper.
Regards,
Peter
Hi Robert,
I look forward to the next X# version!
Thank you for your continued work!
Wolfgang
Good to read that support in the form of critical bug fixes for X# 2.24 remain. I have not found something in the above plans that would justify using .Net8. Not even the alledged speed gain; see W11 speed gain promisses against the reality. But even if programs execute faster, this will not compensate for the expected tons of issues we can expect: new X# versions via NuGet, Winforms programs that rely on something which does not work in .Net8 and the need to get all the VO inherited tools compiled for .Net8 again.
Nevertheless I think it is good thing that X# connects to the latest technology for those who have reasons to use it or connect to it. For now, I am glad that I can keep using X# 2.24 with the option to ask for the occasional bug fix. Unfortunately, the last decade most software gets worse with updates or "new technology" instead of better. Add to that that new technology I adopted early like WPF was eventually neglected because the 'old fashioned' technology (in the WPF case Winforms) kept being used by a majority and I would personally see even less reason to adopt .Net8.
Dick
Hi Dick,
I'm really confident that the X# people will keep X# 3.0 and .NET 8 usable even for us conventional users, and also without being forced to use Nuget.
Wolfgang
Hello Wolfgang,
How can X# 3 be installed without NuGet? I have sometimes been able to avoid NuGet when I could download the package, rename the extensions to .zip and copy the DLL's to the necessary directory where my program points to in References. Is that what you mean? Anyway it wil never works as good as the current X# installer.
Dick
Hi Dick,
I'm pretty sure (and IMHO Robert wrote it somewhere) that the packages will also be a part of the installation of the compiler.
And since X# 3.0 will also be usable with XIDE, and since I know how much Chris likes Nuget, I'm pretty sure you will able to use X# 3.0 also without Nuget.
Wolfgang
Wolfgang is right: we will include our assemblies both as DLLs and as DLLs packaged in a NuGet package.
The DLLs are mainly for use with .Net Framework. The packages for use with newer .Net versions.
The advantage of the NuGet package is that you can define dependencies. A NuGet package for XSharp.VO can tell the build system that it also needs the RDD and Macro compiler. In fact it can include several DLLs in one package.
By including a package reference to XSharp.VO you would automatically include all relevant references.
With DLL references, you need to include all DLL references yourself.
Robert