explaingit

philtomson/kan_lut

Analysis updated 2026-05-18

15JuliaAudience · researcherComplexity · 5/5Setup · hard

TLDR

A Julia framework for training a lookup table friendly type of neural network, called a KAN, and simulating how it would run fast and efficiently on FPGA chips.

Mindmap

mindmap
  root((KAN LUT))
    What it does
      Kolmogorov Arnold Networks
      FPGA lookup tables
      Bit accurate simulation
    Tech stack
      Julia
      Flux.jl
      AMD GPU
    Use cases
      Train KAN on GPU
      Simulate FPGA inference
      Adapt with online learning
    Audience
      ML researchers
      Hardware engineers
    Setup
      Clone repo
      Julia Pkg instantiate
      No license listed

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Train a Kolmogorov-Arnold Network on a GPU and convert it into integer lookup tables for hardware use.

USE CASE 2

Simulate bit for bit how a trained model would behave on real FPGA hardware before building it.

USE CASE 3

Test how well a deployed model adapts to shifting data using small online updates.

USE CASE 4

Run the included classification and digit recognition demos to see the full training to hardware pipeline.

What is it built with?

JuliaFlux.jlAMDGPU.jlFPGA

How does it compare?

philtomson/kan_lutfluxml/flux.jljulialang/julia
Stars154,72548,666
LanguageJuliaJuliaJulia
Setup difficultyhardmoderatehard
Complexity5/53/55/5
Audienceresearcherresearcherresearcher

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1h+

Requires Julia, an AMD GPU for the accelerated training path, and familiarity with FPGA and quantization concepts to follow along fully.

No license information is given in the README, so by default you do not have permission to reuse, modify, or redistribute this code.

In plain English

KAN_LUT is a research framework, written in the Julia programming language, for building a type of neural network called a Kolmogorov-Arnold Network, or KAN, and running it efficiently on a special kind of reconfigurable chip called an FPGA. A regular neural network mostly moves numbers through fixed math operations, but a KAN instead learns curved functions along each connection between nodes, using a mathematical shape called a B-spline. According to the README, this can match or beat the accuracy of a regular network while using far fewer parameters, and because each learned function is simple and per connection, it can be turned into a lookup table on the chip instead of requiring heavy floating point math, which makes it fast and efficient in hardware. The project supports training these networks on an AMD graphics card using a machine learning library called Flux, then converting the trained model into small integer lookup tables that a chip can use directly. It also includes a simulator that mimics, bit for bit, how the real chip hardware would run the same lookup tables, plus support for training with very small numbers of bits per value and for updating the tables in small steps after the model has already been deployed, so it can adapt if the kind of data it sees changes over time. Setup involves cloning the repository and using Julia's package manager to install its dependencies. Two full worked examples are included: a simple two dimensional classification task with two curved, interleaving groups of points, and a handwritten digit recognition task using a shrunk down version of the classic MNIST dataset. Each example shows a full pipeline of training the network, converting it into lookup tables, running it as if it were on real hardware, and then testing how well it adapts when the data distribution shifts, with a script to draw the decision boundaries as an image for the two dimensional example. The programming language is Julia, and the project currently has 15 stars. No license is stated in the README, so its reuse terms are unclear.

Copy-paste prompts

Prompt 1
Walk me through cloning KAN_LUT and installing its Julia dependencies with Pkg.instantiate.
Prompt 2
Explain what happens in each of the five steps printed by the moons demo.jl script.
Prompt 3
Help me understand the difference between the continuous KAN model and the bit-accurate integer LUT model in this project.
Prompt 4
Show me how to load the saved LUT JSON files and run custom inference using inference.jl.

Frequently asked questions

What is kan_lut?

A Julia framework for training a lookup table friendly type of neural network, called a KAN, and simulating how it would run fast and efficiently on FPGA chips.

What language is kan_lut written in?

Mainly Julia. The stack also includes Julia, Flux.jl, AMDGPU.jl.

What license does kan_lut use?

No license information is given in the README, so by default you do not have permission to reuse, modify, or redistribute this code.

How hard is kan_lut to set up?

Setup difficulty is rated hard, with roughly 1h+ to a first successful run.

Who is kan_lut for?

Mainly researcher.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.