https://github.com/tinybiggames/cpascal
🚀 CPascal is a systems programming language that combines Pascal's clean, readable syntax with C's semantic model and full ABI compatibility. ⚡ Compiles to LLVM with zero runtime overhead, enabling seamless interoperation with any C library without bindings. 🎮 Ideal for game development, 🔧 device drivers, and modernizing C codebases. 💎
https://github.com/tinybiggames/cpascal
abi-compatibility better-c c compiler delphi embedded game-development llvm native-code pascal performance programming-language systems-programming win64 windows-11 zero-overhead
Last synced: 6 months ago
JSON representation
🚀 CPascal is a systems programming language that combines Pascal's clean, readable syntax with C's semantic model and full ABI compatibility. ⚡ Compiles to LLVM with zero runtime overhead, enabling seamless interoperation with any C library without bindings. 🎮 Ideal for game development, 🔧 device drivers, and modernizing C codebases. 💎
- Host: GitHub
- URL: https://github.com/tinybiggames/cpascal
- Owner: tinyBigGAMES
- License: bsd-3-clause
- Created: 2025-06-29T19:48:58.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2025-06-29T20:57:03.000Z (6 months ago)
- Last Synced: 2025-06-29T21:34:10.598Z (6 months ago)
- Topics: abi-compatibility, better-c, c, compiler, delphi, embedded, game-development, llvm, native-code, pascal, performance, programming-language, systems-programming, win64, windows-11, zero-overhead
- Homepage:
- Size: 3.91 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project
README
[](https://opensource.org/licenses/BSD-3-Clause)
[]()
[]()
[]()
> 🚧 **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
### **A systems programming language with Pascal syntax and C semantics**
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.
## 🎯 Design Philosophy
> **"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.
## ✨ Key Features
### 🔗 **Full C ABI Compatibility**
- 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
### 📝 **Clean Pascal Syntax**
- Structured programming constructs (`begin`/`end`, `if`/`then`/`else`)
- Strong typing with type safety
- Clear procedure/function distinction
- Readable control flow statements
### ⚡ **Zero Runtime Overhead**
- Direct compilation to efficient machine code via LLVM
- No garbage collection or automatic memory management
- No runtime type information (RTTI)
- Minimal runtime requirements
### 🌟 **Modern Language Features**
- **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
### 🎛️ **Advanced Systems Programming**
- Inline assembly with GCC-compatible extended syntax
- Atomic operations and memory barriers
- Direct hardware access and register manipulation
- Platform-specific optimizations
## 🚀 Quick Start
### Hello World
```cpascal
program HelloWorld;
function printf(const AFormat: PChar, ...): Int32; external;
begin
printf("Hello, World!\n");
end.
```
### Graphics Application
```cpascal
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.
```
### Advanced Features
```cpascal
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 := $3F800000; // IEEE 754 for 1.0
// LValue.AsFloat is now 1.0
end;
```
## 📊 C ABI Type Mapping
| CPascal Type | C Equivalent | Size | Description |
|--------------|--------------|------|-------------|
| `Int8` | `int8_t` | 1 | Signed 8-bit integer |
| `UInt8` | `uint8_t` | 1 | Unsigned 8-bit integer |
| `Int32` | `int32_t` | 4 | Signed 32-bit integer |
| `UInt32` | `uint32_t` | 4 | Unsigned 32-bit integer |
| `Int64` | `int64_t` | 8 | Signed 64-bit integer |
| `Single` | `float` | 4 | IEEE 754 single precision |
| `Double` | `double` | 8 | IEEE 754 double precision |
| `Boolean` | `bool` | 1 | C99 boolean |
| `Pointer` | `void*` | 8/4 | Platform pointer |
| `PChar` | `char*` | 8/4 | Null-terminated string |
**All record types map to C structs with identical layout and alignment.**
## 🏗️ Project Structure
```
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
```
## 🎯 Target Applications
- **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 Features
### Module System
```cpascal
module Graphics;
import Math, Utilities;
{$LIBPATH /usr/local/lib}
{$LINK SDL2}
{$LINK OpenGL32}
public function InitializeGraphics(): Boolean;
private function InternalHelper(): Int32;
```
### Calling Conventions
```cpascal
function StandardFunc(const A: Int32): Int32; // Default (C)
function CdeclFunc(const A: Int32): Int32; cdecl; // C calling convention
function StdcallFunc(const A: Int32): Int32; stdcall; // Windows API
function InlineFunc(const A: Int32): Int32; inline; // Force inline
function FastFunc(const A: Int32): Int32; fastcall; inline; // Combined
```
### Memory Management
```cpascal
var
LBuffer: ^UInt8;
LSize: NativeUInt;
begin
LSize := 1024;
LBuffer := GetMem(LSize); // Allocate
if LBuffer <> nil then
begin
ProcessData(LBuffer, LSize);
FreeMem(LBuffer); // Free
end;
end;
```
### External Library Integration
```cpascal
// External functions
function malloc(const ASize: NativeUInt): Pointer; external;
function SDL_Init(const AFlags: UInt32): Int32; external "SDL2";
function GetTickCount(): UInt32; stdcall; external "kernel32";
// Variadic functions
function printf(const AFormat: PChar, ...): Int32; external;
```
## 🔧 Compiler Features
### Conditional Compilation
```cpascal
{$IFDEF DEBUG}
{$DEFINE ENABLE_LOGGING}
{$ENDIF}
{$IFDEF WINDOWS}
link user32, kernel32;
{$ELSE}
link X11, pthread;
{$ENDIF}
```
### Build Configuration
```cpascal
{$LINK SDL2}
{$LIBPATH /usr/local/lib}
{$APPTYPE CONSOLE}
{$EXEPATH bin/release}
```
## 📚 Documentation
- **[Language Specification](docs/CPASCAL-SPECIFICATION.md)** - Complete language reference
- **[BNF Grammar](docs/CPASCAL-BNF.md)** - Formal grammar specification
- **[Coverage Examples](docs/CPASCAL-COVERAGE.cpas)** - Comprehensive syntax examples
- **[C Migration Guide](docs/C-MIGRATION.md)** - Migrating from C to CPascal
- **[API Reference](docs/CPASCAL-APIREFERENCE.md)** - Standard library documentation
### 📋 **Coding Standards**
- **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
### 🏆 **Contributors**
*Join our growing community of developers building the future of Pascal development!*
## 📄 License
This project is licensed under the **BSD 3-Clause License** - see the [LICENSE](LICENSE) file for details.
```
BSD 3-Clause License
Copyright © 2025-present tinyBigGAMES™ 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.
```
## 📞 Support & Community
### 📚 **Documentation & Resources**
- 📖 **[DEVELOPER-GUIDE.md](DEVELOPER-GUIDE.md)** - 12-section comprehensive development guide
- 📊 **[TEST-REPORT.md](TEST-REPORT.md)** - Current test coverage & performance metrics
- 🔧 **API Reference** - Inline documentation in `CPascal.pas`
- 📋 **Examples** - Real-world usage patterns in test suites
### 💬 **Community Channels**
- 🐛 **Issues**: [GitHub Issues](https://github.com/tinyBigGAMES/CPascal/issues) - Bug reports & feature requests
- 💬 **Discussions**: [GitHub Discussions](https://github.com/tinyBigGAMES/CPascal/discussions) - General questions & ideas
- 💬 **Discord**: [Join our community](https://discord.gg/tPWjMwK) - Real-time chat & support
- 🐦 **Bluesky**: [@tinybiggames.com](https://bsky.app/profile/tinybiggames.com) - Updates & announcements
## 🌟 Acknowledgments
- 💖 **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
### 🎖️ **Special Thanks**
- **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 [tinyBigGAMES™](https://github.com/tinyBigGAMES)**
**CPascal** - *Where Pascal meets C, systems programming becomes elegant.*