The mission

There are many programming languages out there. Most of them brag to be able to create cross-platform applications and to allow you to “easily create rich GUI applications” but miserably fail.

In this book, we will actually achieve true cross-platform GUI applications with code that is 100% portable on Windows, Mac, Android, Linux, etc. I promise it WON’T be a bumpy road!

Your first Hello World application will be a single EXE file, few MB in size that will run on all major platforms without any additional libraries (Java, runtime DLLs, browsers, etc) required.

For whom is this book?

This book is specially written for

• People that have little in programming
• C++ programmers that want to switch to a more productive environment
• Programmers that are advanced but never actually did GUI or cross-platform applications

What you will learn

• What is the best IDE/compiler to develop cross-platform applications (modern, easy, fast, portable)
• Basic programming skills
• How to debug like a pro
• Create GUI applications
• Create less-buggy/more reliable applications
• Advanced debugging techniques

This book is hands-on, pragmatic, and focused on solving real-world issues.

We’ll begin with a gentle introduction to Delphi for newcomers. You will learn what Delphi is, why it excels at GUIs, and how its free license can get you started. We’ll also touch on its darker history — how Micro$oft nearly brought Delphi down.

Next, we’ll dissect the anatomy of a Delphi project to build our first application. From there, we’ll take a quick tour of the IDE before diving into the Delphi language itself.

We’ll then explore object-oriented programming concepts, including classes, constructors, safe memory management, inheritance, polymorphism, and safe typecasting. You will also learn about visual components and their powerful published properties.

For the adventurous, we’ll delve into advanced abstractions, class methods, class fields, and class constructors. Along the way, we’ll discover what is safe to do in Delphi, what isn’t, and—most importantly—why. 

This book is hands-on, pragmatic, and focused on solving real-world issues.

We’ll start with an in-depth look at the Delphi compiler (linker, precompiled libraries, library paths). Then, we’ll move on to advanced debugging: reading call stacks, using advanced breakpoints, remote debugging, and leveraging third-party tools for automated bug reporting and crash data collection. You’ll learn to how to set the compiler to help you pinpoint crashes and even prevent them entirely on your customer’s computer.

Next, we’ll tackle memory management (memory ownership, preventing and dealing with memory corruption) and proper exception handling (covering crashes, access violations, nil pointers, etc). For legacy developers, there’s a section on modernizing old Delphi code for safety, speed, and 64-bit compatibility.

Additional topics include version control, multi-threading, Windows messages, and avoiding common pitfalls like buffer overflows, Application.ProcessMessages, abusing pointers, etc.

I promise that by applying the concepts in this book, your application will run smoothly—without any crashes! 

This book is hands-on, pragmatic, and focused on solving real-world issues.

We’ll start by studying the anatomy of a Delphi package and its famous BPL/DCP files. You’ll learn how packages can help organize your code, break circular references, and will do some Zen, studding the four rules of packaging.

Next, we’ll dive into the inner workings of Delphi’s library system (VCL), including how to recompile parts of it — if necessary.

From there, we’ll explore practical techniques: how to design and set up your own library system, leverage precompiled code to dramatically boost compilation speed, and, of course, tackle the ever-important topic of managing library paths.

While building custom visual components isn’t the primary focus, we’ll dedicate a chapter to it with sample code, including discussions about design-time and runtime packages.

Finally, to become true professionals, we’ll venture neck-deep into the gritty details of packages: the linker, package initialization, constructors and destructors, component streaming, component states, debugging packages, and even the IDE itself.

As you can see, no stone was left unturned in this book! 

The world has gone cross-platform, and your code needs to follow. From configuring the IDE to publishing signed apps in the Google Play and Apple App stores, this book doesn’t miss a step.
This is the practical, hands-on guide to building, styling, and deploying applications across Windows, macOS, Android, and iOS using the FireMonkey FMX framework.

What You’ll Master Right Now

The cross-platform blueprint: Learn exactly why FMX is different from VCL, how the rendering works, and the core architectural differences.

• Setup and deployment: Easy, step-by-step guides for preparing your environment and mastering platform-specific requirements for Android and Apple. PAServer, SDK, NDK, ADB will be no longer esoteric terms to you.
• App store ready: Complete chapters dedicated to the entire process of publishing your app in stores, including setting up provisioning, signing your binaries, versioning, and submission.
• Mastering FireMonkey: Deep dive into the FMX hierarchy, key differences in controls, forms, and dialog boxes, and using modern features.
• VCL to FMX conversion: Explore tools like MidaConverter and ADUG VCL to FMX Converter to help you migrate existing/legacy VCL code and adapt components that don’t have a direct FMX equivalent.
• Code control: Techniques for managing code across platforms using Conditional Compilation Directives and compiler detection to keep your single codebase clean and functional everywhere.
• The app sandbox explained: Understand the concept of the App Sandbox, the anatomy of an App Package, and the critical methods for reliable file deployment on mobile devices.
• Bonus tools – The book discusses tools that you can use to make your cross-platform life easier.