tinyBigGAMES

Calling Delphi Developers! We’re cooking up something special — Logan: local generative aI, unleashed. Right now, we’re testing Logan’s long conversational memory and recall — think persistent, context-aware conversations that actually remember. If you're curious and want to help test it out (or just play), jump into our Discord: https://discord.gg/tPWjMwK Head to the #logan channel — you’ll find the source files there. Check out the usage notes at the top of UTestbed.pas to get started. Your input means a lot. I appreciate you. Notice even when I intentionally spell incorrectly, it's able to discern correctly.

Absolutely, and I completely agree with your concern — it's a valid and important one. Transparency and build reproducibility are critical in today's security landscape, especially with the real risks around supply chain attacks. That's why I'm committed to eventually open-sourcing as much of the code as possible, including build instructions for everything that can be made public. In the meantime, I'm being cautious to stay within the bounds of licensing restrictions while still trying to provide something useful and trustworthy to the Delphi community. I respect that not everyone will be comfortable running binaries without full source, and I encourage that kind of caution. Thanks for bringing it up — it's a conversation worth having.

Additional source code will be released in future updates. Please note that parts of the low-level virtualization rely on a commercial library, so I’m taking care to respect its licensing terms while still contributing meaningfully to the Delphi open-source ecosystem. As development progresses, more of the surrounding implementation built on top of that foundation will be made publicly accessible. For now, the current release reflects the functional portions that are ready to share. Nothing "sus", just can't violate a commercial license agreement.

🔥Pack your game's assets into a single virtual file and access them like a real filesystem! Check out VFolder – a lightweight virtual file system for Delphi. Perfect for GameDev, IndieDev projects and more! 👉https://github.com/tinyBigGAMES/VFolder

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;

🔥 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

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.

🚀 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

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.

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

Yes.

🚀 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

https://github.com/tinyBigGAMES/jetLua

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

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.