I've been working with Delphi for a while now. Every time I read a thread here I realize how much I still don't know, so I figured I'd just ask.
First, is there a trick or habit you picked up the hard way that you wish someone had told you years ago? It could be anything: debugging, memory management, some weird VCL behavior.
Second, if you could add one thing to Object Pascal, what would it be? I have my own wish list but I'm curious what people who've used it much longer than me would pick.
And last, just out of curiosity, what's the oldest Delphi project you still maintain? I keep hearing about apps from the 90s that are still running somewhere and I honestly find that kind of amazing.
Thanks in advance, looking forward to reading your answers.
You ship 600MB of runtimes to execute 50KB of logic. Why?
Electron + Node + bundled CPython + CFFI + a Vulkan SDK + Docker to keep AI-written scripts from nuking the host. That is the "modern" stack.
I took the opposite bet and built my own, top to bottom. Coming up in MIMERCode 1.40 and the next MIMER Polyglot Compiler beta:
- 10 languages (MimerCode, Object Pascal, C, Python, JavaScript, BASIC, Fortran, Java, C#, CLI/IL) compiled to ONE dependency-free native executable: Windows, Linux x64 and ARM64, and bare-metal ESP32
- Cross-language calls by plain source import
- One GUI description, served as a native window or as a multi-user web app, with zero HTML, JavaScript or CSS
There are packages for Delphi 11, 12 and 13 (including the 64-bit IDE). The license is MPL 2.0, so the controls can be used in commercial apps. I've tested it on Windows so far; feedback from macOS, iOS and Android is very welcome.
I need an ODBC 32 bit driver for MySQL. Where can I find that? I have the 64 bit, but it won't work with my Delphi 10.2. Thanks in advance for your help.
I have some old programs written in Delphi 10.2 and after many Windows updates, I have lost the components that I built. Since I use these in my software, I need my library back. Also, when I start Delphi, I get the error in the picture. Below the picture is some of the text I get from the URL.
window._cf_chl_opt._c5ffd9f2bd972d917377e7b8=false;window._cf_chl_opt._00ad1ab20439348ecf6052ce=false;window._cf_chl_opt._e8973c553295cbb0e947a8ed=false;window._cf_chl_opt._9462a494c53affb422b58b7b=[];window._cf_chl_opt._25c48edcaa1c5f265f86ad53="challenges.cloudflare.com";window._cf_chl_opt._b06ffe9637cae679bedecccb={"_431361b1438c22ba0b5edbef":{"_ffe5572c48c4006953a1ea6c":"%2Fcdn-cgi%2Fchallenge-platform%2Fhelp","_e0029a9e5c0eeb4f71217a9c":"https%3A%2F%2Fdevelopers.cloudflare.com%2Ffundamentals%2Fget-started%2Fconcepts%2Fcloudflare-challenges%2F%23browser-support","_21be668b924459f0725afbf8":"https%3A%2F%2Funbotnet.me","_6c80d34bf5264d885678451a":"https%3A%2F%2Fwww.cloudflare.com%2Fprivacypolicy%2F"},"_4c482aba92dc952b32bde90e":{"_daec19a94b6032f2b95d44fa":"%2C%20opens%20in%20a%20new%20tab","_aa2f20de3c989a5257364029":"For%20detailed%20guidance%20on%20how%20to%20update%20your%20device%E2%80%99s%20time%20and%20date%2C%20refer%20to%20your%20device%27s%20documentation%20or%20support%20website.","_5510b255c1c1aa33d41b1a64":"What%20to%20do%20next%3A","_c5d4b6932a2fd63461ea5eac":"This%20verification%20can%20take%20longer%20due%20to%20an%20older%20computer%20or%20a%20slow%20internet%20connection.","_385d70716203cc39f0e29d12":"Privacy","_3957
Questions:
1. What does the error mean?
2. If I click Yes, how will that affect the compile/build?
3. Do I need to re-install?
4. If I uninstall, will, I be able to re-install?
I posted v26.01 here in May. The 26.06 release adds SDK-style encoder and decoder handles alongside the TLzma2 stream API. The low-level units include LzmaLib, Lzma86, and a threaded LZMA2 pull decoder.
Standalone .lzma compression can now run match finding on a worker thread. The CLI has a --memory-limit option for codec allocations.
The VCL app moved from Skia to Direct2D and gained a benchmark tab and language search. Signed builds are available for both tools.
Disclosure: I develop StreamSec Tools, a commercial security library for Delphi (TLS, SSH, X.509/PKIX, CMS, HTTP, mail). Version 4.1.5.363 came out on 9 November. It has no new major features: it is a maintenance release of 100 change-log entries.
**Certificate revocation**
- `LoadCRL` now compares an authenticated CRL with the list held and every list of that issuer and scope in its cache directory, and refuses an older one, also after a restart.
- A certificate store kept answering from a stored revocation verdict for up to `RevocationCacheMaxAge` seconds after a new CRL arrived. A new CRL now ends that.
- A TLS peer whose certificate the store already held had no revocation check, and was accepted after that certificate expired. Both are fixed, with the two known limits the change log states at entry 98.
- The chain check read only the CRLs of the store it ran in, so a CRL held in the store it delegates to did not count against an intermediate CA. It does now.
**TLS**
A TLS 1.3 client did not check the server certificate's EKU or key usage, and TLS 1.2 skipped that for a certificate the engine already knew. Both now check every server certificate.
**Mail**
IMAP `FETCH` now takes the body section forms clients use to list and read messages, sessions are told of new mail, the submission port requires authentication or an address in `RelayNetworks`, an account may give only its own address in `MAIL FROM`, and wrong passwords lock out the source address and not the account.
**A Delphi detail you may want to look for in your own code**
On Linux64, macOS, iOS and Android we called `TTimeZone.Local.UtcOffset.Hours`. `Hours` is the hours component of a `TTimeSpan`, not its length, so at +5:30 it gives 5. The UTC the library worked out was 30 or 45 minutes off in zones with a half or quarter hour.
**Upgrading**
65 of the 100 entries are marked BEHAVIOUR CHANGE in the change log, 46 of them in the mail suite. Read the ones that apply to you first. The likeliest to matter: one `LoadCRL` cache file name per issuer and scope, a handshake with an already known peer can now be refused, `DNSNameToCheck` takes a bare host name, and an access violation on a mail thread now ends the process.
The SBOM is published for the licensed release and describes none of the evaluation builds.
I wrote sgcFSearch, a whole-disk file search tool for Windows 10 and 11 (x64). Press Alt+Shift+Space in any app, start typing, and results appear on every keystroke. It's free, the source is on GitHub under the MIT license, and both downloads are signed.
One of the goals was that it never needs administrator rights. Installing, indexing and live updates all run as the current user.
What it does
Indexes the name of every file and folder on your fixed drives and stays current while files change
Forgives typos: words of 5 letters or more match with one error, so confgi finds config.json
Filters you can click or type, like report ext:pdf mtime:month or type:videos size:>1gb sort:size
Searches inside files with grep:, regex: and sym:, covering text, source code, Office documents without Office installed, OpenDocument, and PDF through the Windows filters
Moves the files you open or copy up the results, and each use counts half as much after 14 days
Includes sgcfs, a command line client with plain, long and JSON output, plus a named pipe API for your own scripts
Numbers from one test PC (C: drive with 3,404,349 files and 447,577 folders, yours will differ)
First crawl: 63 s
Query: 13 to 18 ms
File change visible in search: 308 ms
Restart to ready: 1.0 s
Memory: 306 MB, index file: 202 MB
Current limits
Local fixed drives only, so no mapped network drives or UNC shares
Catching up through the change journal after a restart needs NTFS, other file syser
It's written in Delphi using only the RTL and VCL, with the native NT directory API for the crawl and the NTFS change journal through its unprivileged interface.
This example shows how to use the Embarcadero SmartCore AI components and charting the results using TeeChart.
Components used:
TAIConnection
TAIChatAgent
AIChatAgent1.Instructions.Text :=
'You are a careful business data analyst. Reply first with one valid JSON array of metric objects, no markdown fences.
Each object has metric (short name), value (number), unit (short unit), notes (short explanation).
Example: [{"metric":"Revenue","value":1250.5,"unit":"USD","notes":"Q1 estimate"}].
Then add a short plain-English explanation after the array.
Use numerical values grounded in the user request; when data is missing,
clearly state assumptions and use an illustrative estimate.';
Introducing MiTeC System Information VCL Suite – the new generation of system information components for Delphi.
A completely redesigned library that reads detailed hardware, firmware and software information from Windows computers. Use only the classes you need, or everything at once with the TSysInfo component. All data can be saved to a single file and opened on another computer.
What's inside: • Hardware – CPU, memory, SMBIOS, storage with SMART, NVMe and RAID, displays, USB, Bluetooth, NPU • Firmware and security – BIOS/UEFI, Secure Boot, TPM, BitLocker • Operating system and software – Windows version, installed apps, updates, services, event logs • Network – adapters, connections, Wi-Fi • Monitoring – directories, events, services, network connections, performance
✓ Delphi 10.1 Berlin – Delphi 13 Florence ✓ Win32, Win64 and WinARM64EC ✓ Windows XP – 11, Windows Server 2003 – 2025 ✓ Full source code and free lifetime updates
The new suite replaces MiTeC System Information Component Suite. License owners can upgrade at a significantly reduced price.
I've been using Delphi for desktop for years, and I keep hearing conflicting things about its place in web development. Some people swear by WebBroker/WebStencils for adding web access to existing business logic. Others say the HTTP stack feels like "fighting the tool" compared to modern alternatives.
I'm not interested in a religious war I want practical experience from people who've actually shipped something.
TMS WEB Core or WebStencils + WebBroker or uniGUI or IntraWeb or Others🤔
An introduction to polyglot compilation, shared libraries and code that works together.
What if choosing a programming language did not mean choosing a separate island of tools, libraries and application code?
MPC V90, the version chosen for MPC’s first beta, brings several languages into one native compiler. A JavaScript module can call a BASIC function. A MimerCode interface can use application logic written in another language. And those languages can reach shared services, including a 3D scene, through their own syntax.
The interesting part is what happens between the languages.
Polyglot means “many languages.” A polyglot compiler understands more than one programming language and translates supported programs into executable code. When it also supports interoperability, modules written in different languages can become parts of the same application.
Think of a team whose members speak different languages but agree on how to exchange information. Each person keeps their language. The shared agreement makes collaboration possible.
MPC has frontends for MimerCode, Object Pascal, C, Python, JavaScript, BASIC, Fortran, Java and C#, plus a CLI/IL input path. Each frontend understands its language’s syntax and rules. The compilation paths converge on a shared, structured Pascal representation, which MPC compiles to native machine code.
The V90 packages target Windows x64 and Linux x64. Within MPC’s supported language profiles, execution does not require Node.js, CPython, a JVM or the CLR. The application uses MPC’s matching native libraries. These are defined language profiles, so existing framework and package compatibility still depends on the documented support.
A real call between two languages
Start with a small BASIC module, shared_math.bas:
Function Add(ByVal left As Long, ByVal right As Long) As Long
Return left + right
End Function
Now call it from JavaScript in main.js:
import * as math from './shared_math.bas';
console.log(math.Add(19, 23));
The output is 42. The JavaScript import names the BASIC source file, and the call uses ordinary JavaScript member syntax. MPC connects the exported function and its declared parameter and result types. This example needs no web service, JSON message or separate BASIC process.
This is the smallest useful picture of interoperability: code in one language asks code in another language to do some work, passes values, and receives a result.
What crosses the boundary?
A function name is only the beginning. The compiler also needs to know what each argument means, how the result is represented, and whether an argument is a value or a reference to something the callee may change.
For simple numbers and text, that can feel almost invisible. For arrays, objects, callbacks and resources, the contract matters more. Who keeps a value alive? Can the called function modify it? How does an error reach the caller?
MPC’s interoperability machinery carries information about parameter types, reference parameters, result types and error contracts. Its shared library and channel bindings adapt those contracts to the calling language. This lets ordinary calls stay readable while giving the compiler the information needed to connect them correctly.
One library, familiar imports
Interoperability also means being able to use the same facilities without rewriting them in every language. V90 makes MimerCode standard-library modules available through imports in the other MIMER languages.
Here is JavaScript using the shared string and JSON functions:
import { IntToHex } from 'mimer/stdlib/strings';
import { json_parse, json_stringify } from 'mimer/stdlib/data';
console.log(IntToHex(255, 4));
const plan = json_parse('{"visits":3}');
console.log(json_stringify(plan));
Output:
00FF
{"visits":3}
The corresponding string function is available in Python through from mimer.stdlib import strings, in C through <mimer/stdlib/strings.h>, and in Pascal through uses MimerStdLib.Strings;. These bindings call the same library function that MimerCode uses.
Simple values use the language’s own types. Structured values follow its documented binding: JavaScript and Python use their own values, while C exposes a mimer_value * with explicit release. Functions tied to a MimerCode view, such as report rendering, stay in that view context.
Channels bring the application to life
A channel is MPC’s way to work with a resource or service: open it, call its operations, handle its events, and close it. The shared channel system includes facilities for files, HTTP, GIS and Scene3D.
Here is a complete JavaScript example that creates a headless 3D scene, adds a cube, counts it, and cleans up:
import { Scene3dChannel } from 'mimer/channels/scene3d';
const scene = new Scene3dChannel('scene3d://?ticker=html');
const cube = scene.addCube();
console.log(scene.nodeCount());
scene.removeNode(cube);
scene.close();
It prints 1. This example exercises the scene API without opening a visible viewport. The important capability is direct access to Scene3D from JavaScript through its channel class.
Events travel in the other direction too. The supplied JavaScript Scene3D example registers an onFrame function and pumps events until the handler runs. A channel can therefore invoke application code as well as receive calls from it. Resource access remains governed by the application’s security policy.
Putting it together: one application, several languages
The included Harbour example shows the idea at application scale. A shared MimerCode view provides the interface, while language-specific modules supply scheduling rules and data. In the JavaScript variant, a small MimerCode library connects the view’s named functions to JavaScript logic.
The Harbour pattern: a shared view calls language-specific logic. Libraries and channels provide common services.
The application combines scheduling, visit planning, a workload chart, a map, a 3D site view, local HTTP endpoints and a PDF report. Each part has a role: the view presents information, the rules calculate it, and shared facilities handle the services around them.
That is where a polyglot compiler becomes practical. You can keep a calculation in Fortran, express rules in JavaScript, or build a view in MimerCode, provided the modules expose supported interfaces. A language choice can belong to one part of the application rather than dictate every part of it.
A small place to begin
Put the BASIC and JavaScript files above in the same directory. With the Windows V90 package extracted and a terminal open in that directory, compile them using the package’s compiler and library:
Replace C:\MPC-V90 with your extraction directory. Then change the BASIC function, rebuild, and see the JavaScript caller use the new result.
From there, try a shared library import or a channel. The central idea stays the same: write each module in a supported language, give it a clear interface, and let MPC connect the parts into a native application.
Examples checked with the packaged MPC V90 compiler on Windows x64. Illustrations are schematic.
TMS FNC Localization started in FontCreator. For years, High-Logic localized its font editor with a layer Erwin Denissen wrote himself: a folder of language files and a manager that replaced the text on each form. It worked, but it had no editor, and no other Delphi developer could use it.
Erwin contacted us, and together we turned that layer into TMS FNC Localization. In his words: “It was not designed in the abstract. Every part of it exists because a real application needed it.”
FontCreator now runs on it in 17 languages, on Windows with a VCL application of 88 forms and on macOS with FireMonkey. Each language holds about 3,850 strings, and a full language switch takes about 223 ms.
If you have been looking for a way to keep using CubicExplorer, this is for you.
CubicAdventurer is a revival of CubicExplorer, the extremely customizable Windows file manager by Marko Savolainen. I ported the original source to Delphi 13 (Community Edition) as a 32-bit Windows program. It builds, runs, and looks and behaves like the CubicExplorer you remember.
What you get
- The original interface: tabs, bookmarks, sessions, dockable panels, the folder tree, Quickview.
- The full Tools > Options > Display > Fileview settings, including extension colors, fonts, backgrounds, and per-folder and thumbnail settings.
- Your existing `settings.xml`, `layout.xml` and `sessions.xml` load and save, so you can keep your setup.
- New in this version: folder text color, background colors for System, Read-only and Hidden files, a fallback font for file names with characters the main font lacks, and drag-and-drop arranging in the Bookmarks panel.
- A proper installer. It installs for the current user only and keeps its settings in your `%APPDATA%` folder. A portable version is also available.
Please read before installing
- This is a **beta**, and the first build is a Debug build, so you may see error dialogs (for example "Range check error"). I'm one user on one computer, so I need reports. The text of the dialog and what you were doing when it appeared is all it takes.
- It is a 32-bit program only. There is no 64-bit build yet.
- High-DPI scaling is not handled yet, so on a scaled display it may look off.
The source is under the Mozilla Public License 1.1, the same license as the original. Credit for CubicExplorer belongs to Marko Savolainen; I'm just trying to keep it alive. If you used CubicExplorer, I would like to hear what you miss, what breaks, and what you would like to see next.
Introducing the development team
Derell Licht (https://github.com/DerellLicht) did the design specification, testing, and guidance on the revisions in this project.
Claude AI (https://claude.ai/new) handled key elements of this porting operation, including determining required libraries for modern Delphi, converting existing code to modern Unicode support, and reorganizing interface components under Derell's guidance.
A retro scrolling arcade game called River Run is back from the dead after thirty years!
Back in 1996, as an homage to my favorite Atari 2600 game River Raid, I wrote the original v0.9 beta in Borland Turbo Pascal for DOS. Right as it was being released to FidoNet BBSs and primitive file archives of the day, a silly bug in my setup program prevented most people from even installing it in the first place.
Exhausted and depleted with fighting the compiler and being unable to even debug such a large program with sound and graphics, I was more than eager to get away from the limitations of DOS programming and manual memory management—and was off to the races with Windows programming by way of Delphi.
As a rabid Pascal enthusiast, I pretty much refused to work in C++ or Java commercially even as a software engineer, except for C++ Builder—which we all know is Delphi dressed up in disguise.
Fast forward three decades: I’ve resurrected River Run, porting the original Turbo Pascal code into Free Pascal and Lazarus using SDL2. No game engines and zero bloat from heavy frameworks—just direct procedural code, raw 320 by 200 8-bit palleted graphics, modern CD-quality sound, and even fun new mechanics like full controller and force feedback support.
Storefronts: Releasing November 19 on itch.io and the Microsoft Store, with a free Steam demo following Dec 1st.
Technical Specs At A Glance
Language & IDE: Free Pascal / Lazarus
Graphics & Rendering: Raw 320x200 8-bit palleted graphics using SDL2
Audio: Modern all original 90s soundtrack with custom multichannel dsp engine
Controls & Haptics: Full controller support with force feedback mechanics
Architecture: Pure procedural engine-less code—zero commercial game engines, zero AI, and no heavy frameworks
Future*: Once a Windows build is released, immediate work will begin porting to Android, Mac, Xbox, and PS5. Afterall, all SDL2 code will remain the same.*
I’d love to hear feedback, engine and code discussions, and SDL2 insights from fellow Free Pascal, Lazarus, and Borland veterans!
