AI Researchers, Sharing Open Source Work
These complaints highlight the experience of individual AI researchers releasing new tools and optimizations. They are driven by personal passion and a desire to contribute to the field, but lack a clear path for broader adoption or recognition. The focus is on technical innovation and sharing, not necessarily commercial success.
SOURCES (60)
“This was my Bachelor's Final Project: implementing YOLO26n inference completely from scratch using ARM64 Assembly Language and C, without relying on existing inference frameworks. The goal was to understand how modern neural network inference engines work at a low level and explore optimization techniques for…”
“Hey everyone! A while back I shared an early prototype on reddit for a fuzzy string search idea I was working on. I finally finished implementing it, benchmarked it properly against SymSpell and RapidFuzz. Quick Highlights: Low RAM usage: Stays under 100 MB for a 100k-word dictionary (for comparison, SymSpell d=4 was taking around ~2.7 GB on my setup). Sub-millisecond speed: Runs about ~100x faster than brute-force Levenshtein comparison. Good with insertions and swaps: It handles typos with ext”
“Cuda and Vulkan Benchmark: TensorSharp vs. llama.cpp I would like to share my latest open source local Unsloth (GGUF) LLM inference engine and applications. It supports many models from Unsloth, like Gemma4, DiffusionGemma, Qwen3.6 with multi-modal (image, vision, audio), Qwen Image Edit, reasoning and function tool. It can run on Windows/MacOS/Linux and fully leverage GPU's capability(Nvidia, Apple, AMD, Intel and others supported by Vulkan, CUDA and Metal). The API is completely compatible”
“thanks to everyone for taking the time to try Echo and share feedback, this is precisely why i wanted to launch early.i am going to try to address a couple of topics that came up often:- i'll keep publishing stronger evals, including more difficult coding and agentic benchmarks, to map out more precisely the differences with sota- the public eval dashboard will keep expanding and be updated (very open to more benchmark suggestions as well!)- some people found issues in the eval dashboard ui and”
“> You really should see if you can get the compiler to auto-vectorize first (possibly padding data structures and loops) before you write anything by hand.Counterpoint: https://pharr.org/matt/blog/2018/04/18/ispc-origins> I think that the fatal flaw with the approach the compiler team was trying to make work was best diagnosed by T. Foley, who’s full of great insights about this stuff: auto-vectorization is not a programming model.> The problem with an auto-vectorizer is that as long as vectoriz”
“I've been building an AI that learns to play the classic Snake game through reinforcement learning. The goal is to reach high scores while keeping training time as low as possible. The current version averages 86 points (87 is the maximum) after less than 10 hours of training on a single free Google Colab T4 GPU. To keep training fast, it runs 4,096 Snake games directly on the GPU, combines GPU-native environment simulation with PPO + GAE, and uses a spatially-preserving CoordConv architectu”
“Thank you for replying and for reporting your results. My schtick is AI (i.e. I publish in AI conferences and journals), not maths and I'm interested in the question of autonomy from a professional point of view: how close are we to a machine that can carry out the job of a mathematician like yourself, by itself?If you, e.g. got an LLM (any one) to one-shot the problem with a prompt that said "solve this problem", then we're much closer to that, than if you spent a year trying with different LLM”
“> The problem with distillation attacks I think it's worth stepping back here and pointing out the obvious. Y'all waging war on math. And I'm sorry, but that's the computing equivalent of legislating gravity.Apologies for repeating myself here, but what you call "distillation" is function approximation.I feel for the teams at Anthropic and Open AI, but unlike startups from prior eras; Anthropic and OpenAI have decided to be in the business of selling compute. Not creating a product that us”
“We’re building a robotics data platform with a lot of images, video, and text metadata. For search, we use SigLIP 2. GPUs handle batched asynchronous image/video embedding and indexing, while this small Rust + ONNX Runtime service handles live text queries on CPU. Both land in the same embedding space, so a text query can search the GPU-built image index. The split has been practical for us: keep scarce GPUs focused on high-throughput multimodal ingestion, and scale the lighter query path on reg”
“Hey everyone, I’ve spent the last three weeks compiling custom llama.cpp forks and running imatrix maps on a modified CUDA kernel setup, and the numbers don’t lie. We’ve been looking at model compression completely wrong. Everyone in the community has assumed that 1-bit quantization (like BitNet or ternary quants) is the absolute physical floor for LLM compression. The logic was simple: a weight is either a 1, a 0, or a -1. You can’t use less than one bit of information to represent a state, rig”
“Hey everyone I have been looking into some different options for deploying trained (fine-tuned) Pytorch or HuggingFace computer vision models to production on kubernetes. I have only been looking into open-source solutions like Bento ML, KServe, Ray Serve, Nvidia Triton Infernece Server and the classic pytorch -> onnx -> fastapi wrapper solution. The reason for open-source is to be able to have complete control on how it is deployed and having the tool/framework do the heavy lifting. I'”
What’s about open weight? Isn’t all a black box inside of it?
“Hey r/LocalLLaMA — solo researcher here. I built a new attention architecture and want independent testers. Wave Field LLM replaces O(N²) dot-product attention with FFT wave convolution on a field. Training is O(N log N). Inference is O(1) per token — constant speed and memory even as context grows. Important: this is a base completion model , not a chat model. Trained from scratch. No RLHF, no safety tuning, no instruction fine-tune. What I've measured so far: 80+ tok/s on Mac laptop CPU (n”
“Or more broadly: how do you train a machine learning model to capture the nuances of entirely different, conflicting rule sets? I built a XGBoost classification pipeline to answer that. To stress-test the architecture across heterogeneous environments, I applied it to a highly debated and popular hypothetical: cross-universe power scaling The domain is silly. The engineering underneath it isn't. When predicting outcomes across disparate environments, the core challenge is avoiding a lookup t”
“With the help of a LLM-wiki and a lot of AI, I am running some experiments with dLLMs (and yes, the I does quite some heavy lifting...) Github-Repo: NeoDiffusion ( Neo Diffusion because that's about my fourth attempt, this time I started with the bit of Fable I had available) - I have no idea how I should call the project, but I guess it doesn't even matter. By the by, I didn't mean to make this repo public, so it's a mess, might clean up some other time. So, basically, had an en”
“Spent some time with colibrì (the pure-C engine that streams MoE experts from disk) and put together a hands-on of actually running GLM-5.2 on a single box. The core trick: a 744B MoE only fires a few experts per token, so colibrì keeps the dense part (~10GB) resident in RAM and streams the routed experts off disk on demand. The full int4 model is ~370GB on disk, but you're never holding it all in memory. My Setup: single box, 132GB RAM, Ubuntu 22.04, model on local NVMe. and this is what th”
“I apologize for asking since im still new here But what do you use an Embed model for? It sounds like it can automatically spit out training data for RAG or smth”
I built this Snake demo to show how easy it can be to go from data preparation to training and evaluation with FeynRL. The model is overkill for Snake, but that’s not…
“> And temperature = 0 is not comparable either, because the we will not keep models trained on data of a specific point in time around forever.Equally, if you replace one compiler with another, it is almost certain that the output will not remain stable, even when you have enabled reproducible builds. You are not going to find a difference on the outside, even if implementation may differ under the hood.> You told me nothing I didn't know or didn't expectWhat's in it for you, then? I have been a”
“Hello guys. I want to introduce my recent research presented at ICML workshop. github link : genji970/SRM-LoRA: official implementation of "SRM-LoRA: Sub-Riemannian-Metric Updates for Mitigating LLM Hallucination in Low-Rank Adaptation" ICML2026 Workshop FoGen Shot summarization of Paper. """ SRM-LoRA is a sub-Riemannian-inspired LoRA method designed to reduce LLM hallucination. It builds a sensitivity-based Riemannian metric that reshapes backward gradients in the LoRA”
“Two weeks ago I was on my babymoon in Corfu, Greece. While in transit, I was overseeing a GSoC intern submit an important feature to my array database library, Xarray-SQL. He added `to_dataset()`, which completed the roundtrip between thinking of array data in a tabular model simultaneously as gridded rasters (the premise of the project is that every Nd array can be mapped to 2d, where orthogonal dims of the Nd array are just primary keys of a tabular representation). We discussed in chat, now t”
“limitations: only 45 GPUs qualified for training (90+ days of data), which is a small dataset for ML. Random train/test split was used rather than proper walk-forward validation, so the model may be partially extrapolating existing trends rather than learning causal patterns. I'm actively collecting more data and plan to improve the methodology as the dataset grows. Take predictions as a directional signal, not a precise forecast”
“Context for why this belongs here: it is an open-weights, Apache-2.0 text-to-video model, so it is one of the few video generators you can actually self-host, instead of paying per-second on a hosted API like Runway, Pika, or Kling. The catch is that the official inference stack assumes an NVIDIA box top to bottom, so "self-hostable" on paper still meant "runs on an NVIDIA box I do not own." The 30B MoE version is out of reach on this machine. One base DiT in bf16 is about 60”
“Both versions use the same input data. I also tried different random initial values and got essentially the same result. I didn't test hundreds of inputs, since that would have been mostly a waste of time in this case. The algorithm and the data distribution remain practically the same. What I'm measuring is the machine code that Clang generates for the hot loop.”
“Try it here https://8gwifi.org/online-compiler/ Supported language Java Python C# GoLang CPP RUST Javascript Typescript bash submitted by /u/anish2good [link] [comments]”
“Short version: After weeks of work, I have finally been able to graft a models activations accurately and repeatedly with 0 degradation in the output. The concept is simple enough. Prompt A - Prompt B = X. We then apply X to a new prompt. The new prompt should inherit the difference of the previous prompts. For example Prompt A: Sarcastically convert 72c to f Prompt B: convert 72c to f The difference between the two is "Sarcastically" So with the new activation map of where "Sarca”
“TL;DR: Full GLM-5.2 (753B MoE) quantized to Int4-Int8Mix + NVFP4 4-bit KV cache, TP=4 across 4× DGX Spark (GB10) at 100K context , run on Terminal-Bench 2.1 with the same agent scaffold (Terminus-2) as the official numbers. Result: 63/89 = 70.8% vs the official full-precision 81.0% . Caveat up front: I never ran the full model through my pipeline — the ~10-pt gap bundles quantization plus my 100K-vs-256K context cap, a smaller token budget, and unmatched sampling. So read it as: my whole 4-bit/1”
“GLM-5.2-504B-Code-GGUF is an imatrix calibrated quant of the most liked REAP, which is 0xSero/GLM-5.2-REAP-504B-GGUF . I also uploaded the imatrix file and the modified llama-quant.cpp so you can compile llama.cpp and create your own quant. I wonder how it compares to smaller LLMs like Qwen 3.6 27b and DeepSeek Flash v4. https://huggingface.co/icecubetr/GLM-5.2-504B-Code-GGUF submitted by /u/whiteh4cker [link] [comments]”
“okay so you might be following me or not.. but I have been working in AI since last 10+ years and our first product in AI was released in 2014 https://web.archive.org/web/20141027082348/http://xepan.org/ and we have to take that out as it was just not accepted. Now with this new wave of AI I also started picking my pace. And found that training is okay but running a llm is costly and all models are variants of transformers in one or other way. So I tried with some maths first and some theory...”
“🎉 Excited to share that I’ve published my first Python package on PyPI! SimpleGrad is a lightweight PyTorch-inspired autograd library built from scratch that lets you build and train AI models while learning how automatic differentiation works under the hood. 📦 PyPI: https://pypi.org/project/simplegrade I’ll keep improving it with new features and would love to hear your feedback! #Python #PyPI #OpenSource #MachineLearning #DeepLearning #AI submitted by /u/PerspectiveJolly952 [link”
“Here is my compilation command. (Flame shot is currently broken for me so I couldn't screenshot. https://preview.redd.it/m33lnqd4exbh1.jpeg?width=3072&format=pjpg&auto=webp&s=9a9f6f87db6bdd0ff672e68df7ab35c7545ca38f”
“I'm writing a short series of tutorials on FlashAttention, the algorithm that largely powers modern LLMs. The core idea is to spot the associative structure hiding in the loop. Once you see it, you get two things: you can fuse the passes (in the case of attention, it is huge, because it avoids ever materializing the score matrix) and split and recombine the work across GPU threads or any parallel processor. This post is about recognizing that structure. The stable softmax operation on a vect”
“Hi everyone! I wanted to share some recent progress on TorchJD that might be useful to the machine learning community. When training models with multiple losses (multiple tasks, constraints, auxiliary losses, regularization terms, etc.), you typically have two options: Scalarization: Various ways to combine those losses into a single loss (e.g. average them or combine them with trainable weights); then you can do gradient descent on it. Jacobian descent: Compute the Jacobian of the vector of los”
“Everyone does CV in Python/C++. I did it in Rust anyway – and it worked. 🦀 Libraries compared, code breakdown, and why I chose kornia‑rs submitted by /u/darryldias [link] [comments]”
“Weights, all 4 sizes, Apache-2.0 (ViT-S / ViT-B / ViT-L / ViT-g): https://huggingface.co/collections/robbyant/lingbot-vision Code: https://github.com/robbyant/lingbot-vision Project page: https://technology.robbyant.com/lingbot-vision Self-supervised DINO-family backbone, but the masking is boundary-driven: the teacher predicts where object boundaries are and those tokens get forced into the student's mask, so it can't solve reconstruction by copying flat context. No labels, no text supe”
“Yes, I'll be uploading the base and instruction tuned checkpoint (in pytorch.pt format)”
“I trained with A100 (The 80 GB VRAM variant), using colab pro plus. It took 24+ hours for pre-training. Machine learning is a whole lot about patience lol.”
“I spent the last few months building a new sparse fine-tuning method for MoE models called **USAF**. The goal was simple: if your GPU can run inference on an MoE model, it should also be able to fine-tune it. On my AMD RX 6750 XT (12 GB), I can fine-tune Qwen3-30B-A3B by training sparse expert weights and the router instead of adapters. The project is completely open source under the Apache 2.0 license. I'm not trying to build a business, sell anything, or monetize it in any way—I just wante”
“Hi everyone, I built H64LM, a research project to better understand modern LLMs by implementing one from scratch in PyTorch. Instead of relying on high-level training frameworks, I implemented the core components myself attention, MoE routing, normalization, and the training loop. Features 249M-parameter Transformer Grouped Query Attention (GQA) Sparse Mixture-of-Experts (8 experts, Top-2 routing) with 3 auxiliary routing losses SwiGLU, RoPE, RMSNorm Sliding-window attention Mixed-precision trai”
“All models at the same bit depth / file size (5-8-bf16 mixed quantization). All tests in instruct mode, oMLX benchmarking suite at 50 sample size. submitted by /u/JLeonsarmiento [link] [comments]”
“Much appreciated! First question: I trained on all the subjects all at once (mixed, duduplicated) didn't feel like there was a need to train on each dataset source individually, though to be fair long context continual pre training was done at a different stage compare to shorter context continual pre training. Second question: Chose granite 4 for two reasons: It was a modern apache 2.0, 350M parameter base model albeit with highly outdated information that supported 32K context. I could hav”
“Hey guys, I was playing around with Nanotron recently and got super frustrated by how many heavy, hardware-specific dependencies it imports at the module level ( flash-attn , triton, functorch , etc.). If you try to run it on older or budget GPUs like a T4 or V100, it just crashes on import. So I wrote Picotron ( https://github.com/Syntropy-AI-Labs/picotron ) to solve this. It's a clean-room rewrite that gets rid of all mandatory GPU-specific dependencies. It runs on pretty much any GPU that”
“It is like pytest but for statistical tests: it ensures no regression of your metrics at a statistical level. It manages tedious things such that seeds, past benchmark results, ... Simple CLI working like pytest but with benchmarks/ directory instead of tests/: pybench # 1st time: samples seeds, saves a baseline, marks NEW pybench # later: reruns on the same seeds, marks PASS / FAIL pybench update # re-baseline after an intended change pybench show # print current baseline stats (--history for p”
“I've been experimenting with a compiler/runtime project that I'm not entirely sure is a good idea, so I'd love some feedback from people who've worked on deployment systems. The idea is to compile an exported PyTorch model into a self-contained package that contains: graph binary weights backend kernels (currently WGSL) runtime metadata A lightweight runtime loads that package and executes it directly in the browser with WebGPU. No Python, no server inference, and no dependency o”
“Hi everyone, For the past couple of weeks I have been working on a simulator project considering the shortcomings of MuJoCo. There are things that people like and also don't like about MuJoCo, like the CPU dependency on MuJoCo which makes the simulation not parallelizable beyond a certain limit (depending on the hardware). I know there exists MJX which is GPU accelerated, however, it is not really made for vision based RL pipelines and training. There is also NVIDIA Isaac ecosystem, but that”
“At the end of my last post , I presented an idea: what if I used the core of my last project, the cumulative matrix product, and repurposed it as a positional embedding? I just finished fleshing out the math behind HDD-RoPE and training a model with this positional embedding algorithm, and the results are excellent. When trained on the dataset TinyStories, the validation loss begins to converge a fair amount faster than the baseline transformer trained using xPos. A GPT-2-like model trained on T”
“I've been building a scientific-computing DSL for Python called SolveMath. The goal is to provide a unified interface and DSL that sits on top of scientific libraries and makes scientific computing feel more natural. Current backend: ✓ SymPy ✓ NumPy ✓ SciPy Current capabilities: ✓ Algebra ✓ Integrals ✓ ODEs ✓ Matrix operations ✓ Eigenvalues ✓ Optimization ✓ Tensor contractions Will something like this be useful to people? Would this be worth open sourcing and building an ecosystem around? Ex”
“Hi everyone!! I really wanted to share my research what I've been working on. I've posted about this on locallama and some other subs. I wanted to build a nn that can simulate games, or at least start doing that Most video generators are too large to run on consumer hardware realtime, so I I designed a model that does this from scratch. No fine tuning bs or anything. Just starting from a pretrained VAE The core denoiser network is fully trained from scratch to support this goal. From ima”
“Hi internet friends, I recorded a workshop about building your own LLM without any math / ML prerequisites. It covers everything from machine learning fundamentals, deep neural networks, transformer architecture, and pre/post-training. The only prerequisite is being comfortable with learning through code & excel examples. Sampling Large Language Models Reverse Engineering Large Language Model Perceptrons: wx+b Activation Functions: ReLU, GELU, SwiGLU GPU Coding: PyTorch, torch.compile(), fus”
“I've been working through the internals of LLM inference and writing up what I learn as an open, in-progress handbook. Just wrapped another chapter on GPU execution and memory internals: why a GPU sits mostly idle during inference, how the memory hierarchy gates throughput, and where the real bottlenecks live. Added mermaid diagrams for the architecture pieces so the flow is easier to follow than a wall of text. It's a personal learning project, still growing chapter by chapter. I'd”
“Hey r/LocalLLaMA ! We just released SupraVL-Nano-900k , our first VLM. It has ~900k parameters, was trained from scratch on Flickr8k, and the entire architecture fits in a single Jupyter notebook. This is not a production model, it's a fully transparent, readable blueprint for anyone who wants to understand how image-to-text models actually work under the hood. 🤗 SupraVL-Nano-900k What is this? Most VLMs are black boxes. CLIP encoders, billion-parameter LLMs, fusion layers you can't eas”
“I maintain cuTile Rust and just posted the paper "Fearless Concurrency on the GPU." As more GPU code gets AI-generated, the bottleneck moves from writing it to trusting it. cuTile Rust lets you write or generate GPU kernels whose memory safety and data-race freedom are verified by the compiler, through Rust's ownership and borrow checking. You get those guarantees by construction. It's a tile-based programming model that lowers to CUDA Tile IR, carrying Rust's ownership mod”
“I wrote this technical deep-dive to explore the paradigm mismatch between declarative, set-based processing and sequential, depth-first search algorithms. The write-up walks through the mechanics of forcing a relational database engine (DuckDB) to handle chess logic, specifically: Data Representation: Mapping 64-bit bitboards into a relational model using UBIGINT types. The Pruning Blocker: Why the stateless nature of relational sets prevents sibling nodes from communicating, making true Alpha-B”