<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Magno Lima on Medium]]></title>
        <description><![CDATA[Stories by Magno Lima on Medium]]></description>
        <link>https://medium.com/@lima.magno?source=rss-c344baf93b34------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lsVgx_NZ8W0mWmkQZNZjGQ.jpeg</url>
            <title>Stories by Magno Lima on Medium</title>
            <link>https://medium.com/@lima.magno?source=rss-c344baf93b34------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 20:55:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lima.magno/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[No Opacity: Why This Native Pascal Framework is the Key to Uncovering LLM Secrets]]></title>
            <link>https://medium.com/@lima.magno/no-opacity-why-this-native-pascal-framework-is-the-key-to-uncovering-llm-secrets-06106a0f423a?source=rss-c344baf93b34------2</link>
            <guid isPermaLink="false">https://medium.com/p/06106a0f423a</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[gpt]]></category>
            <category><![CDATA[delphi]]></category>
            <dc:creator><![CDATA[Magno Lima]]></dc:creator>
            <pubDate>Mon, 25 May 2026 22:14:24 GMT</pubDate>
            <atom:updated>2026-05-25T22:14:24.228Z</atom:updated>
            <content:encoded><![CDATA[<h4>Introduction: The “Black Box” Problem</h4><p>In the modern AI landscape, we have reached a point where most developers are merely “prompt engineers” or “API consumers.” We interact with Large Language Models (LLMs) either through an opaque REST endpoint or through massive, multi-layered Python abstractions like PyTorch and TensorFlow. While these tools are undeniably powerful, they act as a “black box,” intentionally shielding the developer from the underlying systems engineering. The logic of the model is often buried under a mountain of library dependencies, making it nearly impossible to see where the mathematical implementation ends and the framework overhead begins.</p><p>This raises a fundamental question for those of us in the trenches: What happens when you strip away the heavy libraries and rebuild a GPT model from the ground up in a high-performance, compiled language? By moving away from interpreted environments and into the realm of native code, we can uncover the true “secrets” of how these models function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lZtU70H7wZTE-TztdvKCKg.png" /></figure><p><strong>Dolphin</strong>, the Pascal GPT Framework, offers exactly this opportunity. It is a native implementation that provides an end-to-end walkthrough of the full AI pipeline for those who want to understand, not just consume.</p><p><strong>Takeaway 1:</strong> Native Performance Without the “Python Tax”</p><p>For too long, deep learning has been synonymous with the “Python Tax” — that inevitable friction involving version conflicts, DLL hell, and the absurdity of 20GB Docker images just to run a text generator. Dolphin bypasses this architectural bloat by targeting <strong>Delphi 12+</strong> and the <strong>Windows 64-bit</strong> platform directly, and it can be compiled to macOS and Linux as well, depending on your Delphi version.</p><p>Instead of relying on external heavyweights, the framework utilizes native Object Pascal code combined with NVIDIA CUDA acceleration. It employs a sophisticated hybrid precision model: <strong>FP64 on the CPU</strong> for numerical stability during weight initialization and gradient calculations, and <strong>FP32 on the GPU</strong> for high-velocity matrix operations.</p><blockquote>No PyTorch, no TensorFlow — just compiled Pascal code, matrix operations, and CUDA kernels.</blockquote><p><strong>Analysis:</strong> From a systems perspective, compiled performance is about more than just speed but also it’s about transparency. When you are working with a native Pascal binary, you gain a direct view of the relationship between code and hardware. Resource consumption becomes explicit rather than hidden behind a garbage collector or an interpreted layer. By utilizing weight caching and pooled memory management, Dolphin allows architects to see exactly how memory is allocated and dispatched to the GPU.</p><p><strong>Takeaway 2</strong>: The Transformer Blueprint Exposed</p><p>Dolphin provides a clear, high-level view of the transformer architecture, exposing the mathematical flow that is usually obscured in library source code. Rather than calling an opaque model.forward() function, you can trace the data as it moves through the blueprint:</p><p><strong>The Architectural Flow:</strong></p><ul><li><strong>Input Text</strong></li><li><strong>↓ BPE Tokenizer</strong> (Token conversion)</li><li><strong>↓ Embedding Layer + RoPE</strong> (Rotary Positional Embeddings)</li><li><strong>↓ Transformer Block (xN)</strong></li></ul><p><em>- LayerNorm</em></p><p><em>- Multi-Head Attention</em></p><p><em>- Residual Connection</em></p><p><em>- LayerNorm</em></p><p><em>- Feed-Forward (GELU Activation)</em></p><p><em>- Residual Connection</em></p><ul><li><strong>↓ Final LayerNorm → Linear Head → Logits</strong></li><li><strong>↓ Softmax → Sampling → Generated Text</strong></li></ul><p><strong>Analysis:</strong> For researchers, seeing the <strong>(xN)</strong> repetition of the transformer block implemented natively is a revelation. Furthermore, Dolphin doesn’t stop at the logits; it exposes the critical “Advanced Generation” strategies that determine a model’s personality and coherence. This includes <strong>Greedy, Temperature, Top-K, and Top-P (Nucleus)</strong> sampling strategies. Understanding these mechanisms is the difference between a model that merely predicts the next token and one that generates human-like prose.</p><p><strong>Takeaway 3</strong>: A Complete, Independent Training Pipeline</p><p>Dolphin isn’t just an inference engine; it’s a complete factory. The framework supports essential training features such as the <strong>AdamW optimizer</strong>, gradient accumulation, micro-batching, and automatic GPU batch-size detection.</p><p>Central to this is the <a href="https://medium.com/p/735d69f8d811"><strong>TDataFrame</strong></a>. While it feels like a “Pandas-like” columnar data structure, its value in a compiled environment is much higher.</p><p><strong>Analysis:</strong> In the Python ecosystem, the data loader is often the bottleneck, constantly shuffling data between the CPU and GPU. The TDataFrame in Dolphin is designed as a pipeline component that allows for <strong>direct GPU batching</strong>. By handling CSV loading, normalization, and shuffling within the native environment, Dolphin minimizes the data-transfer friction that plagues more traditional ML stacks.</p><p><strong>Takeaway 4: </strong>Demystifying Tokenization with BPE</p><p>Tokenization is the critical first step in any LLM pipeline, yet it is often treated as a solved, boring problem. Dolphin utilizes a custom <strong>Byte Pair Encoding (BPE)</strong> tokenizer that relies on a <strong>SQLite-backed vocabulary</strong>.</p><p><strong>Analysis:</strong> Why SQLite? A Technical Architect knows that a vocabulary is a database, not just a list. Unlike a JSON file that must be fully parsed into RAM, creating significant overhead for large models, a SQLite backend allows for indexed lookups and persistence. This makes the vocabulary portable and memory-efficient, allowing for massive vocabularies that can be managed and queried without the usual memory penalties.</p><p><strong>Takeaway 5:</strong> Bridging the Gap with SafeTensors and JSON</p><p>Dolphin is designed to be an integrated part of the broader AI ecosystem. It supports industry-standard <strong>SafeTensors</strong> and <strong>JSON-based configurations</strong>, ensuring that your native work is interoperable with models found on Hugging Face.</p><p>The framework supports a diverse range of training objectives:</p><p><strong>FullModel: </strong>Complete end-to-end pipeline training<br>Exports: safetensors, config.json, vocab</p><p><strong>TokenizerOnly: </strong>Build vocabularies for use in external tools <br>Exports: vocab.json, merges.txt</p><p><strong>Sentence Embeddings: </strong>Train semantic search models via <strong>contrastive learning <br></strong>Exports: safetensors, config.json, vocab</p><p><strong>FineTune: </strong>Start from pretrained weights for specialization <br>Exports: safetensors, config.json, vocab</p><p><strong>Analysis:</strong> This interoperability is vital. It means a developer can use Dolphin to “FineTune” a model or train specialized semantic search models while remaining confident that the outputs are usable in other professional AI workflows. The mention of<em> contrastive learning </em>for sentence embeddings confirms that Dolphin is prepared for modern, nuanced architectural tasks beyond simple next-token prediction.</p><p><strong>Conclusion</strong>: Toward a More Transparent AI Future</p><p>Dolphin provides more than just a framework; it offers a path toward architectural literacy. For those who want to truly understand the mechanics of GPT models rather than just consume them through an API, this native Pascal implementation serves as a powerful engineering tool.</p><p>The next generation of AI innovation will not come simply from building larger, more opaque models. It will come from a deeper, more transparent understanding of the code we already have.</p><p>By democratizing low-level ML engineering through native, readable frameworks, we move closer to an era where AI is no longer a “black box,” but a glass one. If you are ready to reclaim control over your stack and see the math for what it is, it is time to leave the “Python tax” behind.</p><p>Visit now the project <a href="https://dolphin.magnumlabs.com.br/">documentation</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=06106a0f423a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dolphin: High-Performance DataFrames in Pure Delphi]]></title>
            <link>https://medium.com/@lima.magno/dolphin-high-performance-dataframes-in-pure-delphi-735d69f8d811?source=rss-c344baf93b34------2</link>
            <guid isPermaLink="false">https://medium.com/p/735d69f8d811</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[delphi]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[pandas-dataframe]]></category>
            <dc:creator><![CDATA[Magno Lima]]></dc:creator>
            <pubDate>Thu, 26 Feb 2026 13:57:50 GMT</pubDate>
            <atom:updated>2026-09-20T13:26:58.621Z</atom:updated>
            <content:encoded><![CDATA[<h4>Pandas Speed, No Python: DataFrames Built for PascalGPT Pipelines</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/926/1*qG24nxnDp_YJiSOSgLlgPw.png" /></figure><h4>Dolphin, what is that?</h4><p>For years, data science meant Python + Pandas. Today you can get similar productivity — with native speed, full type safety, zero external dependencies, and direct GPU-ready batches — in Delphi.</p><p><strong>Dolphin </strong>is a Pascal GPT framework (PascalGPT) that includes a Data Science core: a pipeline-first toolkit built for end-to-end ML workflows.</p><p><strong>Dolphin for Delphi</strong>, it’s fast and it’s clever!</p><h4>The TDataframe</h4><p>Dolphin <strong><em>includes a core data container (TDataFrame) for tabular datasets</em></strong>. In this article we focus on TDataFrame because it’s the entry point, but it was designed as one stage in a complete training and inference pipeline — data ingestion from TDataSet, zero-copy splits via IDataProvider, and a precision-aware CPU→GPU path (FP64 → FP16 → FP32) with CUDA-ready execution.</p><p>No interpreter, no GIL (Global Interpreter Lock) and no 47-package nightmare. It’s all a just clean and compiled Object Pascal that loads, processes, and feeds data to the GPU in milliseconds.</p><p>Below a video presentation about <strong>Dolphin’s TDataframe </strong>container.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F44oCdYljFzs%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D44oCdYljFzs&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F44oCdYljFzs%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2fb80d70f864c3f97b63027e05846034/href">https://medium.com/media/2fb80d70f864c3f97b63027e05846034/href</a></iframe><p>Live Demo Results</p><h4>1. Real Planets Dataset (1,035 rows, 6 columns)</h4><pre>Loaded 1,035 rows, 6 columns in 146.0 ms<br><br>--- Discovery Methods ---<br>Radial Velocity : 553<br>Transit         : 397<br>Imaging         : 38<br>Other           : 47<br><br>Orbital Period : mean 1,919.70 days | min 0 | max 730,000<br>Planet Mass    : mean 1.3076 MJ     | min 0 | max 25<br>Distance       : mean 206.15 pc<br>Discovery Year : 1989–2014</pre><h4>2. A dummy sample for 100,000 rows × 5 columns (multi-threaded CSV)</h4><pre>Loaded 100,000 rows, 5 columns in 279.8 ms<br><br>--- Pre-processing ---<br>• LabelEncode(&quot;category&quot; → &quot;category_id&quot;)<br>• Z-Score Normalize(&quot;feature_b&quot;)<br>• Shuffle (Fisher-Yates virtual indices — zero data copy)<br><br>--- Framework Extractions ---<br>[FP64] TDoubleMatrix 2×100,000          → 2.4 ms<br>[FP16] feature_a TFP16Matrix            → 1.3 ms<br>[FP32] Full TDeviceMatrix on GPU        → 9.4 ms<br>[FP32] Batch[0] (128 rows) on GPU       → 0.1 ms</pre><h3>Side-by-Side: Dolphin vs Pandas (Real Code from the Demo)</h3><h4>Loading + Strong Typing</h4><pre># Delphi - Dolphin<br>DF := TDataFrame.Create;<br>DF.AddColumn&lt;Single&gt;(&#39;feature_a&#39;, ctFloat32);<br>DF.AddColumn&lt;Single&gt;(&#39;feature_b&#39;, ctFloat32);<br>DF.AddColumn&lt;Integer&gt;(&#39;label&#39;,    ctInt32);<br>DF.LoadFromCSV(&#39;dummy_dataset.csv&#39;);   // multi-threaded Map-Reduce!</pre><pre># Python - Pandas<br>import pandas as pd<br>df = pd.read_csv(&#39;dummy_dataset.csv&#39;, dtype={<br>    &#39;feature_a&#39;: &#39;float32&#39;,<br>    &#39;feature_b&#39;: &#39;float32&#39;,<br>    &#39;label&#39;: &#39;int32&#39;<br>})</pre><h4>Pre-processing (One-liners)</h4><pre># Delphi - Dolphin<br>DF.LabelEncode(&#39;category&#39;, &#39;category_id&#39;);   // string → int32<br>DF.Normalize(&#39;feature_b&#39;);                   // Z-Score in-place<br>DF.Shuffle;                                  // Fisher-Yates, zero-copy</pre><pre># Python - Pandas<br>from sklearn.preprocessing import LabelEncoder, StandardScaler<br>le = LabelEncoder()<br>df[&#39;category_id&#39;] = le.fit_transform(df[&#39;category&#39;])<br>scaler = StandardScaler()<br>df[&#39;feature_b&#39;] = scaler.fit_transform(df[[&#39;feature_b&#39;]])<br>df = df.sample(frac=1).reset_index(drop=True)</pre><h4>GPU Batch Extraction (Zero extra copies)</h4><pre># Delphi - Dolphin<br>DevMat := DF.GetBatchAsDeviceMatrix(128, 0, [&#39;feature_a&#39;, <br>   &#39;feature_b&#39;, &#39;category_id&#39;]);<br>// DevMat is already on GPU — ready for training</pre><pre># Python - Pandas + PyTorch<br>import torch<br>features = torch.from_numpy(<br>    df[[&#39;feature_a&#39;, &#39;feature_b&#39;, &#39;category_id&#39;]].iloc[0:128].values<br>).float().cuda()</pre><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FPLbYf%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FPLbYf%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FPLbYf%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="317" frameborder="0" scrolling="no"><a href="https://medium.com/media/9295ecb1af44753194f123b8885d91e5/href">https://medium.com/media/9295ecb1af44753194f123b8885d91e5/href</a></iframe><h4>Benchmarks: Dolphin TDataFrame vs. Pandas</h4><p>To validate the efficiency of the <strong>Dolphin</strong> ecosystem, we ran a predictive modeling pipeline (SQL ingestion, preprocessing, and GPU tensor extraction) using a dataset of over <strong>400,000 rows</strong>. This benchmark compares the traditional <strong>Python (Pandas/PyTorch)</strong> stack against the native <strong>PascalGPT TDataFrame</strong> implementation. The dataset can be found <a href="https://www.kaggle.com/datasets/alperenmyung/social-media-advertisement-performance">here</a>.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fl5oqa%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fl5oqa%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fl5oqa%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="263" frameborder="0" scrolling="no"><a href="https://medium.com/media/d5d158e59b36fb78a9164b05c4010cfb/href">https://medium.com/media/d5d158e59b36fb78a9164b05c4010cfb/href</a></iframe><h3>Key Takeaways</h3><ul><li><strong>Preprocessing Efficiency:</strong> TDataFrame completed the Label Encoding and Z-Score transformations in nearly half the time required by Pandas.</li><li><strong>Near-Zero Latency Data Splitting:</strong> Shuffling and splitting the <strong>323,174 training rows</strong> was 10x faster in Delphi.</li><li><strong>Eliminating GPU Bottlenecks:</strong> While PyTorch required 70 ms to move a batch to CUDA, TDataFrame’s memory-contiguous columnar storage allowed for <strong>near-instantaneous GPU tensor extraction</strong>.</li></ul><p>This proves that by staying native, we aren’t just matching Python — we are significantly reducing the overhead that typically bakes into AI research workflows.</p><h3>A More Comprehensive Head-to-Head Benchmark</h3><p>To further validate Dolphin’s performance across different workloads, we conducted an extensive benchmark suite comparing <strong>Dolphin TDataFrame </strong>against <strong>Pandas</strong>, testing CSV loading at various scales, common data operations, and GPU transfer scenarios.</p><p><strong>Test Configuration</strong><br>- Most tests: 10 runs with 2 warmup iterations<br>- Data: 10 columns (id, col_1…col_8, category) with 20 category values<br>- Hardware: Same as above (32GB RAM, Nvidia 4070Ti Super 16GB, AMD Ryzen 7 5800X3D)</p><h4>CSV Loading Performance: Scaling Test</h4><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FFT2LD%2F2%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FFT2LD%2F2%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FFT2LD%2Fplain-s.png%3Fv%3D2&amp;type=text%2Fhtml&amp;schema=dwcdn" width="822" height="189" frameborder="0" scrolling="no"><a href="https://medium.com/media/158a9be02795737702f9113fb9b80f50/href">https://medium.com/media/158a9be02795737702f9113fb9b80f50/href</a></iframe><p>The consistent throughput demonstrates both frameworks can handle production-scale data ingestion efficiently.</p><h4>CSV Loading: Multi-Threading Advantage</h4><p>Here’s where Dolphin’s explicit thread control shines. When configured with specific thread counts, Dolphin’s <strong>1-thread performance beats Pandas’ default by 28%</strong>, and with 4 threads, the advantage grows to<strong> 49%</strong>:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FEF4l8%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FEF4l8%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FEF4l8%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="752" height="155" frameborder="0" scrolling="no"><a href="https://medium.com/media/db9eccbbe43181181fa1aacf87a6002e/href">https://medium.com/media/db9eccbbe43181181fa1aacf87a6002e/href</a></iframe><p>This demonstrates Dolphin’s fine-grained control over parallel CSV parsing — critical for developers who need predictable, tunable performance.</p><h4>Data Operations: Different Strengths</h4><p>The frameworks show distinct performance profiles across common operations:</p><p><strong>Normalization (Z-Score on single column):</strong><br>- Dolphin: 11.08 ±0.04 ms<br>- Pandas: 10.18 ±0.18 ms<br>- Winner: <strong>Pandas</strong> (1.09x faster) — marginal difference</p><p><strong>Label Encoding (categorical → integer):</strong><br>- Dolphin: 25.37 ±0.44 ms<br>- Pandas: 17.16 ±0.17 ms<br>- Winner: <strong>Pandas </strong>(1.48x faster)</p><p><strong>Shuffle (Fisher-Yates row reordering)</strong>:<br>- Dolphin: 6.77 ±0.20 ms<br>- Pandas: 98.81 ±4.97 ms<br>- Winner: <strong>Dolphin </strong>(14.6x faster) — dramatic advantage</p><p>The shuffle benchmark reveals a fundamental architectural difference: Dolphin’s zero-copy index-based shuffling versus Pandas’ full DataFrame reordering. For workflows requiring frequent data permutation (cross-validation, stochastic sampling), this <strong>14.6x speedup </strong>is transformative.</p><h4>GPU Transfer: Tale of Two Architectures</h4><p>GPU transfer performance varies dramatically based on batch size, revealing different optimization strategies:</p><p><strong>Full Dataset Transfer (100K rows × 5 columns):</strong><br>- Dolphin: 20.65 ±0.08 ms<br>- Pandas/CuPy: 1.35 ±0.02 ms<br>- Winner: <strong>Pandas</strong> (15.3x faster)</p><p><strong>Small Batch (32 rows):</strong><br>- Dolphin: 0.14 ±0.38 ms<br>- Pandas/CuPy: 0.57 ±0.04 ms<br>- Winner: <strong>Dolphin</strong> (4.0x faster)</p><p><strong>Medium Batch (512 rows):</strong><br>- Dolphin: 0.014 ±0.005 ms<br>- Pandas/CuPy: 0.547 ±0.007 ms<br>- Winner: <strong>Dolphin</strong> (40.6x faster) — <em>exceptional</em></p><p>This pattern is critical for understanding real-world performance:</p><ul><li><strong>Pandas/CuPy excels at bulk transfers</strong> — ideal for training on entire datasets</li><li><strong>Dolphin dominates batch-oriented workflows</strong> — perfect for mini-batch training, real-time inference pipelines, and streaming data scenarios</li></ul><p>The <strong>40.6x advantage</strong> at 512-row batches shows Dolphin’s architecture is optimized for the iterative, batch-based patterns common in modern ML training loops.</p><h4>Performance Summary: Complementary Strengths</h4><p><strong>Dolphin’s Strengths</strong>:<br>- <strong>Multi-threaded CSV loading</strong> (1.28x — 1.49x faster with explicit thread control)<br>- <strong>Zero-copy shuffling</strong> (14.6x faster — game-changing for resampling workflows)<br>- <strong>Batch GPU transfer</strong> (4x — 40x faster for training-sized batches)<br>- <strong>Predictable, tunable performance</strong> through native code and explicit parallelism</p><p><strong>Pandas’ Strengths:</strong><br>- <strong>Default CSV loading</strong> (1.06x — 1.18x faster out-of-the-box)<br>- <strong>Label encoding</strong> (1.48x faster)<br>- <strong>Bulk GPU transfer </strong>(15.3x faster for full-dataset scenarios)<br>- <strong>Mature ecosystem</strong> with battle-tested optimizations</p><p><strong>The Real Takeaway:</strong> Both frameworks are production-ready and performant. The choice depends on your workflow:</p><ul><li><strong>Choose Dolphin</strong> when you need: native compilation, type safety, zero dependencies, explicit control, batch-oriented GPU pipelines, or integration with Delphi/Pascal ecosystems or if you’re interested in understand how the things works behind the scenes.</li><li><strong>Choose Pandas</strong> when you need: the Python ecosystem, maximum out-of-the-box optimization for typical workflows, or full-dataset bulk operations</li></ul><p>For data engineers and Pascal/Delphi developers, these benchmarks prove Dolphin is<strong> a serious alternative</strong> that matches or exceeds Pandas in critical areas while maintaining the advantages of native compilation.</p><h3><strong>Why You Should Try Dolphin?</strong></h3><p>The benchmarks speak for themselves: <strong>Dolphin</strong> is engineered for developers who demand high performance without leaving the Delphi ecosystem. By eliminating the “Python tax,” we’ve achieved significant wins in speed and efficiency.</p><ul><li>Load directly from <strong>any </strong>TDataSet (FireDAC, SQL, TFDMemTable) — no CSV limited</li><li>Zero-copy train/val split with IDataProvider</li><li>Three precision paths: FP64 CPU → FP16 storage → FP32 GPU residency</li><li>Seamless integration with the full <strong>Dolphin Pascal GPT</strong> stack (GPT, Sentence-Transformers)</li><li>Compile once, run anywhere — no virtualenv, no conda, no wheel hell</li></ul><p><strong>Delphi </strong>developers finally get a first-class Data Science toolkit. Developers from Python, C#, JavaScript, Rust, and Go: try Dolphin and help validate a faster, simpler path — benchmarks and feedback welcome.</p><h3>Ready to try it right now?</h3><pre>https://github.com/magnolima/dolphin</pre><p>Welcome to <strong>Dolphin</strong> — where Pascal meets modern AI.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=735d69f8d811" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>