What happened
In a November 16, 2026 post on Fortran Discourse, developer certik describes an experiment to test whether Fortran could be used for local language-model inference. The selected model was Qwen3.8-27B in 8-bit form, which the author says had been released three months earlier. The post links a repository containing C reference, Fortran, and CUDA implementations.
For the Fortran GPU path, the author used do concurrent and says no OpenACC or OpenMP directives were used. On an NVIDIA H200, the author first estimates a throughput ceiling of about 170 tokens per second from theoretical memory bandwidth, and about 150 tokens per second using measured memory speed. The post then gives results for four implementations: 120 tokens per second for the author's C + CUDA version, 102 for LFortran-compiled Fortran, 92 for vLLM, and 72 for llama.cpp.
The author says an AI agent was used to iterate on vLLM and llama.cpp configurations. The selected vLLM setup used CUTLASS, while llama.cpp used flash attention; the post says other combinations were slower. The author describes the figures as the best results obtained after that tuning, while acknowledging that the two established runtimes might be made to run faster. The comparison is therefore specific to this machine, model, implementation, and set of configurations.
The post also reports portability experiments. The same Fortran code runs on CPUs with different Fortran compilers, according to the author. On an Apple GPU through LFortran, it reached 6 tokens per second after an initial regression was fixed; the author estimates a peak of about 17 tokens per second. The author says the implementation contains about 2,000 lines of kernels, while the C + CUDA version has fewer kernels and is roughly three times shorter. That version was also 20% faster than the Fortran implementation in this test.
The author tried NVFORTRAN from NVHPC 26.5, but says it could not compile the original code. A rewritten version ran at 5 tokens per second on the GPU and was excluded from the comparison table. The post's broader claim is exploratory: standard Fortran and compiler-managed offload may be sufficient for this inference path, while the implementation still requires hand optimization and has room to improve.
What the archive adds
New Runtime's earlier coverage has examined other ways to run large models on constrained hardware: Betelgeuse's llama.cpp fork pages MoE experts from NVMe (October 31, 2026), and PLI 4.0.0 splits inference across Apple Silicon compute units (November 3, 2026). This is a new event on a related theme, not a repeat: it tests Fortran GPU offload and compares throughput on an H200.
Trend signal
This is a small, early example relevant to agent economics moving to completed work: builders ultimately care about useful inference delivered per unit of hardware, not just compiler novelty. But the post reports tokens per second, not cost per verified task, and provides no workload-level or cost comparison. It is suggestive evidence about implementation options, not evidence that the economics of agent systems have shifted.
Why it matters
Inference stacks are usually chosen from mature, specialized runtimes, and this experiment does not establish that a general-purpose Fortran compiler can replace them. It does give teams working in scientific computing or performance-sensitive systems a specific hypothesis to test: compiler-managed GPU offload may support a model inference path without adding OpenMP or OpenACC directives to the source.
The trade-off in the reported results is visible. LFortran's Fortran version exceeded the tested vLLM and llama.cpp configurations on this H200, but trailed the author's C + CUDA implementation, which was shorter and faster. That means the relevant decision is not simply language versus runtime. Teams would need to compare their own model, hardware, latency and throughput targets, implementation effort, and maintenance burden before adopting such a path.
Limits and uncertainty
The figures come from the implementation author's own post and are not independently reproduced here. The comparison covers one H200 and one 8-bit model; the post does not establish performance across multiple GPUs, model sizes, batch sizes, request concurrency, or production workloads. It also does not report a standardized benchmark protocol or uncertainty range. The author notes that vLLM and llama.cpp could potentially be tuned further, so the ranking should not be generalized. The reported Apple GPU results are likewise an author's experiment, not a broad portability evaluation.
Reader takeaway
Treat this as a testable compiler and portability experiment, not a new default inference recommendation. The numbers are interesting because a Fortran implementation came close to the author's CUDA version and exceeded the tested configurations of two established runtimes on one H200. Any team considering it should reproduce the comparison on its own workload and include engineering and maintenance costs alongside tokens per second.