CPascal License CPascal LLVM License

🚧 CPascal is a Work in Progress

CPascal is currently under active development and evolving quickly. Some features described in this documentation may be incomplete, experimental, or subject to significant changes as the project matures.

We welcome your feedback, ideas, and issue reports — your input will directly influence the direction and quality of CPascal as we strive to build the ultimate modern Pascal development platform.

CPascal combines the readable syntax of Pascal with the semantic model and binary compatibility of C. It compiles to LLVM IR and maintains full C ABI compatibility, enabling seamless interoperation with existing C libraries and codebases without translation layers or bindings.

"Better C with Pascal Syntax"

CPascal is designed as a modernized systems programming language where every construct maps directly to equivalent C constructs at the binary level. This ensures zero-overhead abstraction and complete compatibility while providing a cleaner, more structured syntax.

• All data types, function calls, and memory layouts identical to C
• Direct linking with any C library without bindings
• Binary-compatible function pointers and structures
• Identical memory layout and alignment rules

• Structured programming constructs (begin/end, if/then/else)
• Strong typing with type safety
• Clear procedure/function distinction
• Readable control flow statements

• Direct compilation to efficient machine code via LLVM
• No garbage collection or automatic memory management
• No runtime type information (RTTI)
• Minimal runtime requirements

• Multiple Assignment: A, B := GetCoordinates()
• Ternary Operator: Max := (A > B) ? A : B
• Compound Assignment: Value += 10, Flags or= 80ドル
• Inline Assembly: Extended assembly with input/output constraints
• Variadic Functions: Full C-style variadic function support
• Module System: Clean imports without preprocessor complexity

• Inline assembly with GCC-compatible extended syntax
• Atomic operations and memory barriers
• Direct hardware access and register manipulation
• Platform-specific optimizations

program HelloWorld;
function printf(const AFormat: PChar, ...): Int32; external;
begin
 printf("Hello, World!\n");
end.

program GraphicsDemo;
import Graphics, Math;
{$LIBPATH /usr/local/lib}
{$LINK SDL2}
{$LINK OpenGL32}
// External SDL2 functions
function SDL_Init(const AFlags: UInt32): Int32; external "SDL2";
function SDL_CreateWindow(const ATitle: PChar; const AX, AY, AW, AH, AFlags: Int32): Pointer; external "SDL2";
const
 SDL_INIT_VIDEO = 00000020ドル;
 SDL_WINDOW_OPENGL = 00000002ドル;
var
 Window: Pointer;
 Running: Boolean;
begin
 if SDL_Init(SDL_INIT_VIDEO) <> 0 then
 exit;
 Window := SDL_CreateWindow("CPascal Demo", 100, 100, 800, 600, SDL_WINDOW_OPENGL);
 if Window = nil then
 exit;
 Running := true;
 while Running do
 begin
 // Game loop
 ProcessEvents();
 UpdateGame();
 RenderFrame();
 end;
 SDL_DestroyWindow(Window);
 SDL_Quit();
end.

module DataStructures;
// Multiple assignment
function GetCoordinates(): (Int32, Int32);
begin
 Result := (100, 200);
end;
// Ternary operator and compound assignment
function ProcessData(const AValues: ^Int32; const ACount: Int32): Int32;
var
 LIndex, LSum, LMax: Int32;
begin
 LSum := 0;
 LMax := 0;
 for LIndex := 0 to ACount - 1 do
 begin
 LSum += AValues[LIndex]; // Compound assignment
 LMax := (AValues[LIndex] > LMax) ? AValues[LIndex] : LMax; // Ternary
 end;
 Result := LSum;
end;
// Inline assembly with constraints
function AtomicIncrement(const APtr: ^Int32): Int32; inline;
begin
 asm
 "lock incl %1"
 "movl %1, %0"
 : "=r" (Result) // Output: register
 : "m" (APtr^) // Input: memory location
 : "memory" // Clobbered: memory
 end;
end;
// Union types
type
 TValue = union
 AsInt: Int32;
 AsFloat: Single;
 AsBytes: array[0..3] of UInt8;
 end;
var
 LValue: TValue;
begin
 LValue.AsInt := 3ドルF800000; // IEEE 754 for 1.0
 // LValue.AsFloat is now 1.0
end;

All record types map to C structs with identical layout and alignment.

project/
├── src/
│ ├── main.cpas # Program entry point
│ ├── graphics.cpas # Graphics module
│ ├── audio.cpas # Audio module
│ └── platform/
│ ├── windows.cpas # Platform-specific code
│ ├── linux.cpas
│ └── macos.cpas
├── lib/
│ ├── SDL2.lib # External libraries
│ └── OpenGL32.lib
└── build/
 ├── obj/ # Compiled objects
 └── bin/ # Final executables

• Systems Programming: Device drivers, OS components
• Game Development: High-performance game engines
• Embedded Systems: Microcontroller programming
• Performance-Critical Applications: Real-time systems
• C Codebase Modernization: Gradual migration from C

• Language Specification - Complete language reference
• BNF Grammar - Formal grammar specification
• Test & Coverage Report - View current test results and feature coverage.
• C Migration Guide - Migrating from C to CPascal
• API Reference - Standard library documentation

• Naming: L prefix for locals, A prefix for parameters
• Declarations: Each variable on separate line, no inline var
• Parameters: Always const unless var/out needed
• Testing: Comprehensive tests for all new functionality
• Documentation: Update relevant guides and inline docs

Join our growing community of developers building the future of Pascal development!

This project is licensed under the BSD 3-Clause License - see the LICENSE file for details.

BSD 3-Clause License
Copyright © 2025-present tinyBigGAMESTM LLC
All Rights Reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice
2. Redistributions in binary form must reproduce the above copyright notice
3. Neither the name of the copyright holder nor the names of its contributors
 may be used to endorse or promote products derived from this software
 without specific prior written permission.

• 🏠 Homepage: CPascal Homepage – Official website, documentation, and news
• 🐛 Issues: GitHub Issues - Bug reports & feature requests
• 💬 Discussions: GitHub Discussions - General questions & ideas
• 💬 Discord: Join our community - Real-time chat & support
• 🐦 Bluesky: @tinybiggames.com - Updates & announcements

• 💖 Built with love for the Delphi community
• 🎯 Inspired by Pascal's readable syntax and C's systems programming power
• 🚀 Focused on practical, real-world usage scenarios
• 🏆 Committed to enterprise-grade quality and performance
• 🌍 Supporting the future of Pascal application development

• Delphi Community - For continued support and feedback
• Beta Testers - Early adopters who helped shape CPascal
• Contributors - Everyone who has submitted issues, PRs, and improvements

Made with ❤️ by tinyBigGAMESTM

CPascal - Where Pascal meets C, systems programming becomes elegant.