An Open Implementation Flow for the Xilinx Spartan-3E and Spartan-6 that Runs in the Browser, Checked Byte for Byte Against ISE

Pedro MaloarXiv 2026 · arXiv

TL;DR

This paper introduces Silinx, an open-source FPGA implementation flow for legacy Xilinx Spartan-3E and Spartan-6 devices that runs entirely in a web browser. By reverse-engineering bitstreams through "black-box observation," the author created a toolchain that is byte-for-byte compatible with official Xilinx tools while often producing designs that are 20% smaller and 10% faster.

What Problem Does This Paper Address?

Many popular FPGA development boards used in education, such as the Digilent Basys2 and Nexys3, rely on the Xilinx Spartan-3E and Spartan-6 families. Unfortunately, these chips are only supported by Xilinx ISE 14.7, a proprietary toolchain discontinued in 2013. ISE is notoriously difficult to install on modern operating systems, often requiring heavy virtual machines.

While open-source flows exist for newer FPGAs (like Lattice iCE40 or Xilinx 7-series), older families have been left behind. This creates a barrier for students and hobbyists who want a lightweight, modern environment for digital design without the overhead of legacy proprietary software.

Methods

The author developed a complete flow—from Hardware Description Language (HDL) to bitstream—that runs in the browser or Node.js using WebAssembly.

The Silinx implementation flow, showing the integration of Yosys, nextpnr, and the custom bitstream writer.

Key components include:

  • Synthesis: Uses Yosys and the ABC logic optimization tool to convert HDL into a netlist of FPGA primitives.
  • Place and Route (P&R): Employs nextpnr (specifically the Himbaechel framework) to decide where components go on the chip and how to connect them.
  • Bitstream Reverse Engineering: To create a bitstream writer without access to Xilinx's internal data, the author used "black-box observation." They generated thousands of designs using ISE, compared the resulting bitstreams, and mapped specific bits to hardware features.
  • Codeword-Batched Experiments: Instead of testing one routing switch at a time (which would take hundreds of thousands of runs), the author assigned binary "codewords" to switches. This allowed them to identify thousands of switches in just a few dozen ISE runs.
  • Validation: The flow uses ISE as an "oracle." For any given placement and routing, Silinx must produce a bitstream that is byte-identical to the one generated by ISE's bitgen tool.

Datasets

The flow was evaluated using a corpus of 67 open-source designs, including:

  • CPUs: T80, light8080, PicoRV32, NEORV32, SERV, and FemtoRV32.
  • Peripherals: UART, SPI, I2C, and FIFOs.
  • Cryptographic Cores: AES, SHA-1, SHA-256, and SipHash.
  • Benchmarks: EPFL combinational benchmarks, ITC’99, and VTR.

Key Insights and Ideas

  • Modern Synthesis Wins: Even though the target hardware is old, modern open-source synthesis tools (like Yosys/ABC) are significantly more efficient than the decade-old XST compiler in ISE. This allows Silinx to pack logic more tightly.
  • Tractable Reverse Engineering: The "codeword batching" technique was decisive. It reduced the effort of documenting the Spartan-3E database to about 7,000 ISE runs (roughly a week of automated compute) rather than an impossible manual task.
  • Browser-First Portability: By compiling the entire stack to WebAssembly, the toolchain removes installation barriers. It can run on locked-down school computers, tablets, or any device with a modern web browser.
  • Safety through Refusal: The router is restricted to only use switches that have been successfully measured and verified. If a design requires an unmeasured feature, the tool refuses to generate a bitstream rather than risking hardware damage.

Key Results

The author compared Silinx against ISE 14.7 across 45 designs that both tools could successfully build.

Summary of Silinx performance vs. ISE 14.7 across different optimization goals.
  • Area Efficiency: Silinx uses 15–21% fewer slices (the basic logic units of Xilinx FPGAs) than ISE across all optimization goals.
  • Timing Performance: At the "Area" goal, Silinx's critical paths are 14% shorter (faster) than ISE's. At the "Speed" goal, they are 8% shorter.
  • Robustness: Silinx successfully implemented 15 designs that the official XST compiler could not even read due to modern Verilog/VHDL constructs.
  • Speed: Build times are generally much faster; at the "Area" goal, Silinx is roughly 80% quicker than ISE.

Limitations and Future Work

  • Device Descriptions: The compact device descriptions used for P&R are still derived from ISE's text reports (xdl -report).
  • "Fast" Goal Performance: While Silinx wins on Area and Speed goals, its "Fast" goal (prioritizing tool runtime over quality) currently produces paths that are 12% longer than ISE's.
  • Coverage: While core logic, routing, RAM, and multipliers are covered, some complex configurations for DCMs (Digital Clock Managers) and PLLs are not yet fully measured.
  • Oracle Scope: The ISE oracle checks bitstream and routing legality but does not currently validate placement quality.

Summary updated

Abstract

The author describes an open implementation flow, from HDL to a programmable bitstream, for the Xilinx Spartan-3E (XC3S100E to XC3S1200E) and Spartan-6 (XC6SLX16, XC6SLX45), devices that only the discontinued ISE 14.7 supports. The flow runs unchanged in a web browser or in Node.js: Yosys and nextpnr compiled to WebAssembly, with nextpnr's Himbaechel framework given Spartan-3E and Spartan-6 architectures generated from Silinx's own device descriptions, bit database and timing model, and Silinx's own bitstream writer. The bit database was built by black-box observation of ISE's documented XDL and bitgen tools, using codeword-batched experiments; the router is given only switches whose bits were measured, and the writer refuses a feature it has not measured. ISE is the oracle: for the same placed and routed design, the bitstream is byte-identical to the one bitgen writes and ISE's DRC is clean. Placement and routing were first done by an in-house annealer and PathFinder router, which nextpnr replaced once it matched them. On 67 open-source designs for the XC3S1200E, compared with ISE at the same optimisation goal (45 designs built by both), the flow uses 15% fewer slices and has 14% shorter critical paths at goal Area, 21% fewer slices and 8% shorter paths at Speed, and 20% fewer slices but 12% longer paths at Fast (geometric means). XST cannot read 15 of the designs. The flow is published as the npm package silinx-fpga (Apache-2.0).
BibTeX
@misc{malo2026open,
  author = {Pedro Malo},
  title = {{An Open Implementation Flow for the Xilinx Spartan-3E and Spartan-6 that Runs in the Browser, Checked Byte for Byte Against ISE}},
  year = {2026},
  eprint = {2611.13008},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13008},
}

Loading related content...

Figure