Some new projects...

[tinyBigGAMES 79]

Here are a few recent projects I've created that might be useful to others:

• CScript: C99 Scripting Engine for Delphi
  🅲🆂cript represents a sophisticated 🅲99 scripting engine meticulously crafted for experienced 🧑‍💻 Delphi developers. Leveraging the compact yet highly versatile TinyCC compiler, 🅲🆂cript seamlessly integrates ⚙️ dynamic backend code generation into the Delphi development environment. With 🅲🆂cript, Delphi developers can 🛠️ compile and execute 🅲 scripts at runtime, directly in 💾 memory, and generate output in the form of 🪟 Win64 executables (.exe), dynamic-link libraries (.dll), or 📂 object files (.obj).
• MemoryDLL: In-Memory Win64 DLL Loading & Execution for Pascal.
  The MemoryDLL unit provides advanced functionality for loading dynamic-link libraries (DLLs) directly from memory in Win64 environments. Unlike traditional methods that involve loading DLLs from the file system, MemoryDLL allows you to load DLLs from byte arrays 📂 or memory streams 💾, retrieve function addresses, and unload them—all in-memory. This library is ideal for Delphi/FreePascal developers who need to manage DLLs without relying on the filesystem, enhancing both performance ⚡ and security 🔒.
• PSFML: SFML for Pascal
  PSFML is a Pascal binding for the ⚡ Simple and Fast Multimedia Library (SFML), providing Pascal developers with a straightforward way to utilize SFML’s multimedia features directly in their projects. Whether building 🎮 games, 🤖 interactive applications, or 🎥 multimedia tools, PSFML integrates smoothly with SFML, bringing robust multimedia functionality to the Pascal ecosystem.

Enjoy! 👀

[tinyBigGAMES 79]

Here are a few more projects:

• PLUA: Lua for Pascal
  PLUA is a lightweight and powerful 📦 that integrates LuaJIT scripting into Delphi, enabling you to easily add a scripting layer to your Delphi apps. Whether you're building dynamic software 🖥️, adding mod support 🛠️, or simply looking for a way to make your apps more flexible and customizable, PLUA makes this possible through simple, straightforward APIs.
• CPas: Static C Libraries for Delphi
  A collection of hand-picked, high-quality C libraries, compiled into a single translation unit and seamlessly integrated into Delphi. This approach eliminates the need for external DLLs, runtime extraction, or loading them in memory, simplifying the development process and reducing potential compatibility issues, such as antivirus 🛡️ interference.
• Mamba Game Toolkit: Advanced 2D Game Library for Delphi.
  Mamba Game Toolkit (MGT) is a sophisticated yet easy-to-use 2D game development library for Delphi. Tailored to meet the needs of Windows developers, MGT offers a streamlined approach to building 2D games, focusing on simplicity, performance, and reducing external dependencies. With everything linked directly into the executable️, it eliminates the need for runtime DLLs, simplifying deployment and enhancing the overall stability and reliability of your projects.

Enjoy! 👀

Edited November 21, 2024 by tinyBigGAMES

[limelect 51]

I tried some projects to compile with D10.2.3 and all had errors

 all kind so I gave up.

Only your about component compiled OK

P.S no FMX.fhtmledit

Edited November 22, 2024 by limelect

[havrlisan 33]

10 minutes ago, limelect said:

I tried some projects to compile with D10.2.3 and all had errors

 all kind so I gave up.

Only your about component compiled OK

P.S no FMX.fhtmledit

I'll never understand people like you. Every project except CScript has a Requirements section where he mentions that Delphi 12.2+ is supported, or at least that it is made and tested with Delphi 12.2. You really should RTFM more often.

[limelect 51]

Thanks

[Patrick PREMARTIN 115]

Good idea for PLUA project. I've seen an old LUA package for Pascal but it wasn't maintained.

 

@tinyBigGAMES You open many projects but globally only for Windows, do you want to try other platforms in the future ?

[tinyBigGAMES 79]

4 hours ago, Patrick PREMARTIN said:

Good idea for PLUA project. I've seen an old LUA package for Pascal but it wasn't maintained.

 

@tinyBigGAMES You open many projects but globally only for Windows, do you want to try other platforms in the future ?

Hi, thanks! At the moment, I'm only targeting Windows. Mostly because much of that audience is on Windows. I won't rule out other platforms, however. The products that I create are for clients using Windows. The libs are open source so if anyone wishes to port to other platforms, go for it. Note that often, a library may take express advantage of a feature that is limited or unique to the Windows platform, however. In the case of games for example, the last time I looked at the Steam stats, the vast majority of users there are still on Windows. It's no debate that Windows still has the best development tools, and it is still much easier to release on it. But, like I said, I'm not against it per say, just that for me, in the current moment, I have no need or desire to release anywhere else.

[tinyBigGAMES 79]

What if you wanted an even smaller Lua integration for Delphi? Just using stock Lua 5.4.7+, statically linked directly into your Delphi executable with no external overhead, and automatic registration of native Delphi routines, all in a single unit? Introducing Chandra - Lua Scripting for Delphi.

A client needed a tiny, simpler, but capable Lua scripting solution than my recently released PLUA. The Chandra.o file (just Lua compiled into a single translation unit) is linked directly into Delphi via {$L Chandra.o} with ~600kb overhead. It can directly register published Delphi class methods via RTTI.

Enjoy, happy coding! 👀

https://github.com/tinyBigGAMES/Chandra

[tinyBigGAMES 79]

https://github.com/tinyBigGAMES/jetLua

 

[tinyBigGAMES 79]

🚀 Explore My GitHub Projects! 🌟  
Check out my current GitHub tools and libraries I’ve been working on!  

🎮 JetInfero 
Local LLM Inference Library  

🎨 Aurora Game Toolkit
Advanced Game Development Toolkit

📦 JetZip
Zip It Fast, Zip It Easy!

🤖 Lumina
Local Generative AI Toolkit

🔥 Pyro
Pyro Game Library for Delphi  

🛠 CPas
Static C Libraries for Delphi

📀 PSFML
SFML for Pascal Developers

🧠 MemoryDLL 
In-Memory DLL Loading & Execution for Pascal

🕹 DSDL   
SDL for Delphi Developers

🌕 Callisto 
Lua Scripting for Delphi

📜 CScript 
C99 Scripting Engine
 

Edited January 26 by tinyBigGAMES

[shineworld 85]

There are other projects, eg: Chandra, Infero, jetLua, LMEngine, etc which are disapeared from git...

Are become obsolete and replaced by some newone ?

[tinyBigGAMES 79]

36 minutes ago, shineworld said:

There are other projects, eg: Chandra, Infero, jetLua, LMEngine, etc which are disapeared from git...

Are become obsolete and replaced by some newone ?

Yes.

[tinyBigGAMES 79]

Sophora is a local generative AI toolkit for Delphi, powered by the DeepHermes-3

model and the latest llama.cpp optimizations. It enables fast, efficient, and unified

reasoning, making it ideal for AI-driven applications that require high-performance

local inference without relying on external cloud services. With features like function

calling, embedding generation, retrieval-augmented generation (RAG), and deep

inference capabilities, Sophora provides developers with a versatile and powerful

toolset for integrating AI into their Delphi projects. By supporting optimized

execution on modern hardware, including compute capability 5.0+ GPUs via Vulkan

for acceleration, it ensures smooth and efficient model operations.

tinyBigGAMES/Sophora: Sophora - AI Reasoning, Function-calling & Knowledge Retrieval
 

 

Edited February 26 by tinyBigGAMES

[tinyBigGAMES 79]

EasyJson - tinyBigGAMES/EasyJson: EasyJson - Effortless JSON Handling for Delphi with Fluent Simplicity.
libFPC - tinyBigGAMES/libFPC: libFPC - FreePascal in your pocket!
Dlluminator - tinyBigGAMES/Dlluminator: The sleek new way to load Win64 DLLs straight from memory — no disk, no traces, no limits.

Edited Saturday at 06:31 PM by tinyBigGAMES

[tinyBigGAMES 79]

🚀 NEW PODCAST ALERT: #libFPC Deep Dive! 🎧

Just dropped a fresh episode exploring "FreePascal in your pocket" by @tinyBigGAMES! 💻

We're unpacking how this portable compiler system lets you carry the power of #FreePascal wherever you go! Perfect for rapid prototyping and collaboration on the move. 🔥

• 📱 Learn how libFPC makes Object Pascal development more accessible
• 🛠️ Discover cross-platform capabilities without the bulk
• 💪 Hear expert tips for maximizing this lightweight compiler

Whether you're a Pascal veteran or curious about compact development tools, this episode has something for everyone!

Listen now 🎙️

Grab libFPC from GitHub:
https://github.com/tinyBigGAMES/libFPC
 

Edited Tuesday at 10:10 PM by tinyBigGAMES

[Rollo62 565]

Thanks, this is a great library and introduction.
Can your libFPC also be configured to generate and run an Pascal code in memory at specific periodic schedules, lets say like every 1st of April or so?
 

[tinyBigGAMES 79]

2 minutes ago, Rollo62 said:

Thanks, this is a great library and introduction.
Can your libFPC also be configured to generate and run an Pascal code in memory at specific periodic schedules, lets say like every 1st of April or so?
 

Thanks! Sure, see Test04 and Test05 as examples of in-memory generation/execution. Just program the running host app to run at the specified time. It should work just fine. The possibilities are endless.

[tinyBigGAMES 79]

🔥 libFPC v1.0.0 is out! Compile & run Pascal code at runtime—directly from memory. EXEs, DLLs, icons, version info, source-from-string, and more! Perfect for plugins, sandboxes, & scripting.
👉 https://github.com/tinyBigGAMES/libFPC

[tinyBigGAMES 79]

Simple example showing how to do interop in libFPC between host and DLL. Note, when passing strings and you want the string experience vs passing PChar/PWideChar, use WideString. They are managed like string/UnicodeString but by the OS rather than Delphi/FPC. The memory manager is not shared across the DLL boundary, so this is necessary. In a real app, the TContext and any other things that are shared between the host/dll can be put in an include file or, depending on the complexity, a unit that is shared between them.
 

type
  TContext = record
    GetVersion: function(): WideString; stdcall;
    Test1: procedure(const AValue: Int32); stdcall;
    Test2: procedure(const AValue: WideString); stdcall;
  end;

function  Test07_GetVersion(): WideString; stdcall;
begin
  Result := '1.0.0';
end;

function  Test07_GetDescription(): WideString; stdcall;
begin
  Result := 'Testing interop between host and DLL';
end;

procedure Test07_Test1(const AValue: Int32); stdcall;
begin
  MessageBox(0, PWideChar(Format('Int32: %d', [AValue])), 'Host EXE', MB_OK);
end;

procedure Test07_Test2(const AValue: WideString); stdcall;
begin
  MessageBox(0, PWideChar(Format('WideString: %s', [AValue])), 'Host EXE', MB_OK);
end;

procedure Test07();
const
  CCode =
  '''
  library source;

  uses
    sysutils,
    windows;

  type
    PContext = ^TContext;
    TContext = record
      GetVersion: function(): WideString; stdcall;
      Test1: procedure(const AValue: Int32); stdcall;
      Test2: procedure(const AValue: WideString); stdcall;
    end;

  procedure Run(const AContext: PContext); stdcall;
  begin
    MessageBoxW(0, PWideChar(UnicodeFormat('Version: %s', [AContext.GetVersion()])) , 'Context DLL', MB_OK);
    AContext.Test1(2025);
    AContext.Test2('This is a string from Context DLL');
  end;

  exports
    Run;

  end.
  ''';

var
  LlibFPC: TLibFPC;
  LHandle: THandle;
  LContext: TContext;
  Run: procedure(const AContext: PContext); stdcall;
begin
  LContext.GetVersion := Test07_GetVersion;
  LContext.Test1 := Test07_Test1;
  LContext.Test2 := Test07_Test2;

  // Create an instance of TLibFPC
  LlibFPC := TLibFPC.Create();
  try
    // Assign the Pascal source string to compile
    LlibFPC.SetProjectSource(psString, CCode);

    // Set the output path to the in-memory cache directory
    LlibFPC.SetOutputPathToCacheDir();

    // Turn off debug mode
    LlibFPC.SetDebugMode(False);

    // Compile the file and check for success
    if LlibFPC.Compile() then
    begin
      WriteLn('Created DLL...');                // Notify DLL creation

      // Attempt to load the DLL from cache
      LHandle := LlibFPC.LoadDLL();
      if LHandle <> 0 then
      begin
        WriteLn('Loading DLL...');              // Notify DLL load

        // Resolve the 'Test01' exported procedure
        Run := GetProcAddress(LHandle, 'Run');
        if Assigned(Run) then
        begin
          WriteLn('Extracted and running export...'); // Notify success
          Run(@LContext);                             // Execute the export
        end;

        FreeLibrary(LHandle);              // Unload the DLL after use
        WriteLn('Unloaded DLL...');
      end;
    end
    else
    begin
      WriteLn('Failed!');                        // Notify compile failure
    end;
  finally
    // Free the instance to release resources
    LlibFPC.Free();
  end;

  Pause();                                       // Wait for user input before exit
end;