Postgres LISTEN/NOTIFY has a bad reputation thanks in part to a popular blog post asserting it does not scale. If that were true, it would be a shame, because LISTEN/NOTIFY is a powerful tool, allowing you to use your Postgres database for low-latency durable notifications, streams, and pub/sub. The accusations aren’t wrong: NOTIFY has unintuitive and undocumented performance characteristics arising from its use of a global lock. But “unintuitive behavior” is not the same as “not scalable.” In this blog post, we’ll show how we optimized LISTEN/NOTIFY-backed streams at scale, achieving 60K writes per second on a single Postgres server with millisecond-scale latency.

Low-Latency Streaming with LISTEN/NOTIFY

The basic design of Postgres-backed streams is simple: create a streams table where each stream chunk (for example, an LLM response token) is a new row, then write to streams by inserting into the table.

The tricky part is reading from the stream because you don't know when the next chunk will arrive. One solution is polling: have each reader poll the end of the stream for new chunks. However, polling scales poorly. If the polling interval is set too high, latency is too high for interactive use-cases (e.g., online chats). But if the polling interval is set too low, concurrent pollers overwhelm the database.

The better solution is LISTEN/NOTIFY. This allows readers to block waiting for a notification from a writer that a new chunk has been published to the stream. That way, readers don’t waste resources polling, but wake up immediately when a new stream chunk arrives.

In our initial implementation of LISTEN/NOTIFY-based streams, a trigger on the streams table fired a function that sent a notification every time a new stream chunk was written. Readers waited for these notifications and woke up to a new stream chunk.

This implementation was correct and delivered low latency, but at scale its throughput was poor. Even using a large Postgres database, it could not sustain more than 2.9K stream writes per second. Interestingly, it bottlenecked without visibly consuming any Postgres resource (CPU, memory, or IOPS). As you may have guessed, the root cause was the original “LISTEN/NOTIFY is not scalable” issue: a global lock Postgres takes during NOTIFY. But why does Postgres do that, and how can we optimize it without losing the benefits of Postgres notifications?

The LISTEN/NOTIFY Exclusive Lock

To understand the problem, we’ll need to examine how Postgres LISTEN/NOTIFY actually works.

The root cause of the poor performance is that in Postgres, committing a transaction that calls NOTIFY requires taking a global exclusive lock. This lock is taken as the transaction begins to commit, and is not released until the transaction is fully committed and its contents have been flushed to disk with fsync().

This lock is necessary because Postgres guarantees that notifications are sent in transaction commit order. To enforce this, it stores all outgoing notifications in a global internal queue whose order must exactly match the commit order of the transactions sending those notifications. Adding notifications to this queue must be done transactionally as part of the commit. However, Postgres doesn’t assign transactions a commit order until those transactions are done committing, as committing can take a variable amount of time.

This creates an ordering problem: transactions containing notifications must add themselves to the queue in commit order, but commit order isn’t defined until the commit is complete. The solution is the global lock, which serializes commits of transactions containing notifications, so their commit order is defined ahead of time and they can correctly order themselves in the internal notifications queue. 

This exclusive lock explains the poor performance we observed. Because we call NOTIFY from a trigger on the streams table, every stream write includes a call to NOTIFY. In order to commit, each stream write needs to take the global lock and hold it for the entire duration of its commit, including the flush to disk. This means that stream writes need to commit sequentially, precluding Postgres’s usual optimizations like group commit (which commits many transactions together in a single fsync()). As a result, stream writes can complete no faster than Postgres can commit transactions, which leads to this bottleneck. This also explains why we did not see significant consumption of any Postgres resource such as CPU or disk: there wasn’t any, because all transactions were serialized by a global lock.

As an aside, there’s been some online discussion of a Postgres patch related to this issue. This patch (to be released in Postgres 19) does not remove the global lock or fix the bottleneck we observed. Instead, it optimizes the narrower case where there are many notification channels and each listener is waiting only on a specific channel.

Optimizing LISTEN/NOTIFY

To make LISTEN/NOTIFY-backed streams faster, we have to work around this bottleneck. The key observation is that for streams, and for many other applications of LISTEN/NOTIFY, the notifications aren’t themselves a source of truth. Instead, they just ping a reader to check a database table (the real source of truth) for new data. As a result, notifications don’t have to be globally ordered or perfectly durable, so we can optimize NOTIFY by buffering notifications in memory and periodically flushing them in a single batch transaction, significantly reducing contention on the global lock.

Buffering and batching NOTIFYs avoids the bottleneck because the global lock only needs to be taken when the buffer is flushed, not for each individual stream write. This means that individual stream writes can proceed quickly, taking advantage of Postgres optimizations like group commit to obtain high throughput, while the buffer flushes in the background.

Adopting a buffer introduces a new complication, which is that a process crash while notifications are buffered leads to those notifications never being delivered. To solve this issue, we add a fallback to stream readers: in addition to waiting for notifications, they also periodically poll the database to check if the stream was written to without a notification. The frequency of this polling can be low (because it is only a fallback for undelivered notifications), so it does not significantly affect performance.

Benchmarking this optimized solution, we see massively improved performance: in the presence of concurrent readers, we can perform up to 60K stream writes per second (20x more than before) while still obtaining 15-100ms latency. At maximum throughput, Postgres CPU is fully utilized, showing the database is actually saturated instead of bottlenecked on contention.

Learn More

All benchmark code is available on GitHub: github.com/dbos-inc/dbos-postgres-benchmark

If you like building scalable, reliable systems, we’d love to hear from you. At DBOS, our goal is to make Postgres-backed durable execution as simple and performant as possible. Check it out:

• Quickstart: https://docs.dbos.dev/quickstart
• GitHub: https://github.com/dbos-inc
• Discord community: https://discord.gg/eMUHrvbu67

It seems I have just built the world’s first open source switch ASIC and I am getting it back from the fab mid november.

Switch floorplan render with area density view enabled, occupying 711.2 x 325um of area. The first version of this chip is currently taped out on the Tiny Tapeout gf26b shuttle chip, part of the second wafer.space run. Silicon bring-up is expected to start 2026-11-15.

Here is its repository :

Essenceia/ethernet_switch_asic

Open source sillicon for a 100Mbps unmanaged cut-through ethernet switch.

Verilog

9

0

Buckle up and welcome to the tale of more madness.

Recommended soundtrack for reading: Taishi - Reverie for Another Sphere

Where are the open source networking ASICs?

Recent FCC decisions have put the central importance of networking equipment top of mind, and in doing so, have also put the total absence of any entirely open source networking equipment hardware at the top of my mind.

Although Open Source Silicon is in its infancy we are currently seeing a number of projects being designed, tested, and for the most ambitious ones, even taped-out with some proven silicon already in the wild.

Awesome Kian-V project, a silicon proven RISC-V SoC fabbed on wafer.space run 1. And yes, it runs Linux. Link to the original post.

That said, the vast majority of the most ambitious projects are predominantly RISC-V SoCs.

Surprisingly, there has been much less interest in building open hardware for networking equipment.

Well .. unsurprisingly actually … networking equipment is far less “sexy” than CPUs and has thus received much less attention from the open source community. On the other hand, this means there’s a huge untaped boulevard of projects open to anyone with more time than common sense to build open source networking equipment chips!

Because, on the other side of the great silicon divide, the world of open source networking equipment is actually quite rich, both in terms of its flourishing software ecosystem and the open PCB/electronics ecosystem, with a flurry of fully featured open source routers available. Yet, due to the current ecosystem’s limitations, under the hood, these are all still all running closed-sourced, blackbox proprietary chips for the central compute and routing tasks.

So what would it take to build a router chip?

It’s a very ambitious project, since a router involves a complex SoC needing both a powerful enough CPU to run the networking stack alongside specialized networking hardware, and analog frontends for the wired and wireless connections. Since building a full router outright is much too ambitious of a greenfield project for a single person to ever hope to pull off, let’s begin with a more approachable first step: building a switch. After all, although most people only have one router, you can have a number of smaller switches, and we also don’t have any open source chips for those.

Oh and, I am not talking about building an FPGA switch, oh no, I am talking about building a switch ASIC, taping it out and then proving the silicon works.

Switch Flavors

Before we start figuring out what kind of switch we want to build, let me give you a quick overview of the different flavors of switches out there. Readers deeply familiar with networking equipment can skip this part.

Glossary

Physical Layer

Ethernet supports multiple physical layers, outlined in the 802.3 IEEE spec. Each clause in the spec defines the underlying medium characteristics for carrying the Ethernet protocol over the medium at a given bandwidth.

Both a 10 Gb fiber Ethernet link and a 10 Mb coaxial cable can carry Ethernet packets and, to the layers above the physical layer, the packets will look exactly the same.

Where they will differ is at the physical layer and, outlined in the spec is precisely how, with which timing and with what encoding data will be transmitted over the medium.

This ensures that devices made by different manufacturers agree on what “talking Ethernet” looks like, making them interoperable.

So one of the first questions I must answer is which physical layer my switch should support. This will define how much traffic I must route, how fast I should do so and how much bandwidth I can carry.

Managed vs Unmanaged

The second question is: what type of switch do I want to build?

There are two big families of switches: managed and unmanaged. As the name implies, managed switches can be configured and managed from the outside. This allows for much smarter routing, such as supporting different VLANs.

While unmanaged switches are essentially unconfigurable pieces of networking equipment that you plug into your network and just work (until power surge do you part).

Cut-through vs Store-and-Forward

The last switch characteristic is cut-through versus store-and-forward.

Cut-through switches start forwarding a packet while the packet is still arriving, leading to much lower networking latency, whereas store-and-forward switches wait for the entire packet to arrive before checking that no corruption has occurred, and then only forward the packet if that check passes.

Where issues arise is when a packet is corrupted, a cut-through switch might still forward it, propagating corrupted packets through the network since forwarding began before the FCS (frame check sequence) could be checked.

Designing against constraints (again)

As usual with my ASIC design work, what I build is shaped as much by what I want to build as it is by the constraints of the silicon.

Pins

My first major constraint is the pins: not only in their amount but also in their maximum bandwidth.

Since I will be taping this first generation chip out over the Tiny Tapeout shuttle chip, using purely digital tiles, I’m constrained by the limits of these pins.

In total this will afford me 24 pins: 8 input, 8 output, and 8 bi-directional (configurable to be either inputs or output pins) GPIO pins, rated to run reliably at 50 MHz on both inbound and outbound data.

The absence of any analog front end makes building anything IEEE-physical-layer-compliant directly a challenge, but there’s a way around this: using an external PHY (physical layer) chip and interfacing with it over the standardized RMII bus. Though this consumes 7 bits per Ethernet interface it makes my 50Mbps pins capable of sending and receiving over 100Mbps Ethernet (100BASE-TX).

Tiny Tapeout shuttle chip

IndexInputOutputBidirectional0ui[0]uo[0]uio[0]1ui[1]uo[1]uio[1]2ui[2]uo[2]uio[2]3ui[3]uo[3]uio[3]4ui[4]uo[4]uio[4]5ui[5]uo[5]uio[5]6ui[6]uo[6]uio[6]7ui[7]uo[7]uio[7]

I will be targeting the widely available Microchip LAN8720A/LAN8720AI (which will be the only mention of AI in this article) PHY chip for this interface. I will be going more in-depth as to how this ASIC will be interfacing with this PHY later.

Area

My second major constraint is my limited die area.

I am paying for all this out of pocket afterall, and more area means a higher manufacturing cost. Now I am not trying to accumulate a pool of gold or anything, it’s just that, in compliance with Maslow’s hierarchy of needs, waffles rank higher than area, and higher manufacturing cost means less waffles. So just like any semi-conductor company, I am incentivised to keep my area budget under control.

Maslow’s hierarchy of needs, distorted ASIC edition.

Because store-and-forward requires the switch to store the entire packet before forwarding it, and because ethernet frames can reach upwards of +1.5k Bytes (and +9k for jumbo frames), they require massive amounts of storage. A workaround for that would be to store the packet to some off-chip memory but I don’t have the pin budget to afford that right now, so on-chip memory is my only option.

The problem is, on-chip memory consumes a lot of area given the large area footprint of SRAM and the even larger area per stored bit footprint of flip-flops.

Now if we were talking of a few bytes this could be negotiable, but for multiple 1.5k Bytes packets this is a dealbreaker, thus ruling store-and-forward out.

Very very high resolution render of the switch ASIC floorplan using Tim Edward’s excellent OCD 256x8 SRAM IP, for scale. The SRAM macro features two banks and is on the right of the floor plan placed in the W (west) orientation.

Assuming I was using Tim Edward’s excellent OCD 256x8 SRAM IP, a single 256 Byte SRAM occupies 301.3 x 224.93 um (using W orientation in this implementation) and consumes just by itself 1/3 of the floorplan. If we want to store even a single full packet we would need 6 of such instances, and since we have 3 ports, we would then need to replicate that 3 times, so 18 instances in total. Now, we have a larger 1028 Byte version of this SRAM that is 301.3 x 515.81 um which nicely increases our storage area density. But again, if we were to instantiate six such macros this would occupy x3 the area than we currently have to spare.

Now, the Tiny Tapeout shuttle chip does support me scaling up this design up at most another two factors of two, or 4x. But the cost would also scale by a factor of 4, at which point we are getting into full chip orders of magnitude of cost. And if I were to go down the full chip route, since I then have the possibility of having a lot more pins to play with, this re-unlocks the possibility of interfacing with much larger external memories, thus changing the landscape of what the correct technical tradeoff would be again.

RTimothyEdwards/gf180mcu_ocd_ip_sram

3.3V SRAM macros for GF180MCU, based on the original 5V SRAM macros.

Verilog

22

5

Easy to use

Lastly, I want something that doesn’t require external software or configuration.

Firstly because I would like external third party users in the community to be able to easily pick this ASIC up and start using it. And that becomes increasingly difficult as soon as I start involving custom software. I am aiming for something that is as close to plug and play as possible with ease of use being a measure of success.

Not to say that the community won’t be able to compile and flash my custom embedded abominations, just that their willingness to do so decreases exponentially with each extra step.

Secondly because I am once again working on a very tight schedule and that custom software support adds significant amounts of time to both the pre-tapeout and bringup workloads. (Let’s not forget we are still talking about a single person’s project here.) This would be especially true for this ethernet switch project since I would aim to be compatible with a widely adopted open source switch management software and protocol like SNMP for monitoring or SSH for monitoring and configuration.

Support for these protocols is not at the level of something I can trivially implement in hardware, especially for SSH, and the best design decision would be to offload to a CPU. So either integrate an on chip CPU on the ASIC or, build a custom interface to an external MCU and offload all these requests to it. Both options involve a significant software effort, with the on chip CPU also promising a huge design effort and even more area usage. At which point, I am approaching the planned architecture of the router rather than the first generation of the switch.

So, for both of these reasons, an unmanaged switch is the path I am taking.

What are we building?

So to recap, I am building a:

• 3-port
• Full-duplex
• 100 Mbps bandwidth
• cut-through
• unmanaged

ethernet switch.

Now that we have figured out what we’re building, it’s time to focus on the fun part: how to build it! 🥳

System Overview

The real Ethernet frame that is hidden from view

Most people have actually never seen a full ethernet packet.

When you inspect Ethernet traffic on your computer via tcpdump or wireshark, you actually only see part of the Ethernet frame, with some parts missing. These parts are generally stripped out by your computer’s network interface before the packet is forwarded to the software realm, thus hiding them from user’s view.

Random IPv4 packet captured over tcpdump (tcpdump -xx -e -v 'ether proto 0x0800') :

16:36:51.298082 60:e9:aa:92:dc:7d (oui Unknown) > 5c:e9:31:1e:9d:00 (oui Unknown), ethertype IPv4 (0x0800), length 78: (tos 0x2,ECT(0), ttl 64, id 0, offset 0, flags [DF], proto UDP (17), length 64)
    superpitchu.53332 > dfw25s53-in-f9.1e100.net.https: UDP, length 36
    0x0000:  5ce9 311e 9d00 60e9 aa92 dc7d 0800 4502
    0x0010:  0040 0000 4000 4011 2b98 c0a8 0085 4a7d
    0x0020:  0369 d054 01bb 002c a93f 6fe8 5bd5 5378
    0x0030:  f4c9 ccae 477c 5083 0696 8fa4 4f62 57bf
    0x0040:  41a9 78a3 fc60 7781 2b8b 38a1 2ccd

The missing parts are:

• Preamble + SFD: Before the start of the MAC header exists a sequence of 7 bytes of an alternating bit sequence signifying that a packet is about to start, called the preamble, followed by a 1-byte marker ending in a double asserted bit sequence called the SFD (Start Frame Delimiter) signaling that the next bits are the MAC header.
• Frame Check Sequence Footer: At the end of the packet there is a 4-byte footer called the FCS (Frame Check Sequence), used to check whether the Ethernet frame’s content was corrupted during transmission. This is checked by both store-and-forward switches and by most computers’ network interface cards and these drop all frames that fail this test before the packet is forwarded.

Raw packet overview

And since, once they have been evaluated by the networking interface, both the Preamble+SFD and FCS serve no further relevant purpose, they are stripped out before the remaining packet bits are forwarded up the networking stack.

Now, since we’re going through the Microchip PHY, we won’t actually be interfacing directly with the Ethernet physical layer, as it will be abstracting away the precise 100BASE-TX PHY behavior, though the full ethernet frame will remain intact (including Preamble+SFD+FCS)

All our data transmission and reception will actually be done through the RMII bus interface.

The RMII interface

LAN8720A to application device interface diagram taken directly from the LAN8720A/LAN8720AI datasheet. For our application the MAC and RMII block are going to be part of our ASIC and we will have 3 such interfaces in parallel. Like in this example, both the ASIC and all the 3 LAN8720A chips will be driven by the same external 50MHz reference clock signal.

RX

• rxv valid signal (crs_dv in the diagram above )
• rxer error signal
• rxd[1:0] two data signals

On the RX (reception) side of RMII, we have four pins: two for data, one for data validity, and one to signal that an error has occurred on the line. Interestingly, this valid signal isn’t a pure data-valid signal but an early data-valid signal, and it’s up to our ASIC to read the incoming data and correctly identify when the Ethernet frame data actually starts using the preamble and SFD. The valid signal actually asserts asynchronously a few cycles before the start of the preamble but, deasserts synchronously with the end of the Ethernet frame.

TX

• txv valid signal (txen in the diagram above )
• txd[1:0] two data signals

On the TX (transmit) side, we only have three signals: two for data and one for valid, with no error signal. This makes sense, since the error signal is there to indicate issues on the medium, and since there is no medium between the ASIC and the PHY there is no need for it in the TX direction.

Timing

Lastly the PHY chip’s datasheet outlines the expected timings for the interface signals.

Unlike what my high level overview might have suggested, new data isn’t immediately available at the start of the clock cycle. Like in all real hardware there is an internal propagation delay. The same goes for how fast the data is allowed to transition after the start of a cycle. Because the PHY chip also contains flip-flops and is thus also subject to hold constraints, the previous cycle’s data must remain stable for a certain period of time after the clock edge before the new value can be propagated.

RMII interface timing for the LAN8720A/LAN8720AI Microchip chip family. Documentation code: DS00002165C. I swear, this doc is so well written, it truly makes this chip such a pleasure to work with ❤️.

So, implementing correct signaling alone isn’t enough to properly interface with this chip. If I want my ASIC to work I also really need to make sure my physical implementation’s resulting timing respects these constraints. This is both verified and enforced by specifying design constraint rules as part of the SDC (Synopsys Design Constraints) file.

Now by designing around the constraints of the LAN8720A chip readers might be concerned that I am locking myself into a dependency on a single external chip.

And actually that is kind of the case here, I am not proud of this but I caught this discrepancy too late, and not mentioning it in this article simply doesn’t align with the technically honest recollections I am looking to do here.

Since RMII is regented by the RMII consortium, and since in the RMII specification they include the AC characteristics I blindly assumed the LAN8720A would be compliant.

Turns out the LAN8720A isn’t actually compliant.

And, although in many cases the LAN8720’s timings are actually more constraining than the official spec, when it comes to the hold constraints on the RX pins it is actually much looser at 1.4ns less than the RMII’s consortium’s 2.0ns.

Although this might still work in practice, it would be by pure luck and I only believe in engineered luck!

RMII Specification, AC Characteristics

So note to self for future versions: I should set this to 2.0ns to guarantee that the ASIC would work with other RMII chips.

Apart from that, the LAN8720A is widely available, easy to get dev boards for, well documented, and at 103 cents a piece, worth every penny.

The official Microchip LAN8720A development daughterboard not only came with a real paper datasheet but it was the most precious tiny datasheet I have ever seen.

ASIC pinout

Putting it together, here is what the final pinout of our ASIC will look like connected to all 3 PHY chips. We will be referring to these as PHY0, PHY1 and PHY2.

Indexui (Input)uo (Output)uio (Bidirectional)0phy0_rx_data[0]phy0_tx_data[0]phy2_rx_data[0]1phy0_rx_data[1]phy0_tx_data[1]phy2_rx_data[1]2phy0_rx_vphy0_tx_vphy2_rx_v3phy0_rx_err-phy2_rx_err4phy1_rx_data[0]-tx_phase5phy1_rx_data[1]phy1_tx_data[0]phy2_tx_data[0]6phy1_rx_vphy1_tx_data[1]phy2_tx_data[1]7phy1_rx_errphy1_tx_vphy2_tx_v

Note: As a reminder, there are a total of 24 pins: 8 inputs, 8 outputs and 8 bidirectional pins.

Address Resolution

At its heart, a switch is actually a conceptually simple piece of networking equipment whose role is to read and forward incoming Ethernet frames to the correct ports. Matching incoming packets destination MAC addresses to the correct port is accomplished by an internal structure called an address table.

Like a software dictionary construct, it maps a destination MAC address to a switch port index.

In order to build this correspondence, the switch reads incoming traffic’s source MACs, keeping track of which port each source MAC was seen on, in order to forward future traffic to the correct port.

Putting it together: when an incoming Ethernet frame arrives, the switch first reads the destination MAC from the frame header and checks the address table for a matching entry. If there’s a hit, it forwards the packet to the specified port. And in cases where there is no hit, in a best effort to minimize packet drops, it broadcasts the frame on all ports except the one it came from.

At least that is the high level overview, in practice, this is hardware, so things get a bit more hard (pun intended … no, I am not sorry).

Filling the table

Recall that this switch is unmanaged, it needs to autonomously learn the correct ports corresponding to each device’s MAC address. It does this by reading the source MAC of all incoming Ethernet frames. Once it has the source MAC, it checks the address table to see if this MAC is already present. If no entry exists, it writes a new one.

The requirement that all entries in the table be unique is not only a correctness requirement but also stems from two physical implementation constraints (see ASIC implementation rules for readers not already deeply familiar with ASIC design ):

• Most efficient utilization of the table: since the table is implemented in hardware not only is its size fixed but each additional entry is non-linearly more expensive. Since this first generation 3 port design only features 4 such entries it is imperative to make the most use of each entry, and duplicated entries are a pure waste.
• Timing: lookup of this address table is on the critical path. But by guaranteeing that each hit is unique, we can replace the priority mux selecting from individual entry hit to the table hit, with a lower logic depth and/or reduction tree. See the code below as an example for the entry port hit to table port hit.

always @(*) begin
    /* verilator lint_off CASEOVERLAP */
    (* parallel_case *) // telling synthesizer it can optimize this from a priority mux to a parallel case
    casez(mac_hit) <- onehot0 entry hit vector
        4'b???1: port_hit = mem_port_q[0];
        4'b??1?: port_hit = mem_port_q[1];
        4'b?1??: port_hit = mem_port_q[2];
        4'b1???: port_hit = mem_port_q[3];
        default: port_hit = {PORT_IDX_W{1'bX}}; // port hit will only be used if we have at least one valid entry hit
    endcase
    /* verilator lint_on CASEOVERLAP */
end

So, like all hardware structures, this table has a limited, fixed size. In the best case, assuming there are multiple free entries, a static allocation algorithm is used to select which entry the new address is written to. If there is a single free entry it is used.

Where things get complicated is when there are no available entries. To explain what happens in this case, I need to take you on a quick detour and talk about Time-To-Live (TTL).

Time-To-Live 🪦

Each entry in the table actually has three parts: the MAC address, the port, and a time-to-live counter.

Address table entry memory layout. Each entry uses 54 bits of storage, and the first generation switch has 4 such entries.

So, why am I sacrificing some of my very precious on-chip storage for this counter? Well, because I must !

It implements an aging mechanism: entries in the table are only valid for as long as their TTL hasn’t expired. This is a necessary mechanism for networking equipment, to make sure old entries aren’t kept alive as it could result in improper forwarding.

Imagine the following scenario: a device is connected to our switch on port 0, but then it’s disconnected from port 0 and re-connected to port 1. If that device never transmits again, the switch has no way of being made aware that the port for this device has changed. So without an ageing mechanism, as long as the entry isn’t re-allocated, it would continue forwarding all packets destined for that device to the wrong port. Meanwhile, all traffic destined for the device would be lost.

Because of this, all switches, let they be managed (or unmanaged) implement such an ageing mechanism, where entries are regularly purged from the table. In our switch, this TTL counter also indicates whether an entry is valid (TTL != 0).

Then, at a regular interval, a hardware internal event is triggered and all the table’s TTL values in the table are decremented by 1.

This TTL is a hard-set 300 second (5 minute) invalidation cycle. All entries, if not refreshed within this five-minute window, will ultimately be invalidated.

Replacement policy

Coming back to our write example, what happens on a write when we have no invalid entries?

For cases like this the hardware implements a replacement policy.

Firstly, in parallel to the other address table lookup mechanism, the hardware keeps track of the oldest valid entry based on the TTL. For cases where multiple entries have the same age, we once again have a static tiebreaking rule. This oldest entry is called the victim and is selected for new allocations.

Now, in my explanation so far I have suggested we had 2 distinct cases:

1. At least 1 invalid entry
2. No invalid entries

But in practice, since the first case is actually a generalization of the replacement policy where entries ages are 0 the replacement policy is always used for allocating new entries. The distinction is actually between allocating entirely new entries (for which the MAC address isn’t in the table) and existing entries.

Updating existing entries

Even for cases where we detect we have an existing entry we also want to perform a write to the table for two reasons:

Firstly, it is rewritten in order to refresh its TTL counter back to the maximum value, keeping active ports entries alive.

Secondly, we also re-write the port index, to correctly handle the corner case where the device might have been connected to a different port compared to when it was originally allocated.

And with this we have ourselves an address table for our switch. 🎉

War stories

For this ASIC design I stuck to my classic project roadmap so after having finished writing the design and it having survived torture testing simulation I moved to the last validation step which was FPGA emulation.

This last step is particularly important for devices such as these that are expected to correctly interface with third party equipment and for which the testbench might not do a proper job at capturing all the corner cases.

And, let me, dear reader, tell you a funny story that happened while I was running this emulation.

Picture this: it was an early 3am, I had finished bringing up the switch and everything was working as expected. At this point my mind was fixated on actively debating whether I should head off to bed and get a wink of sleep or toughen it out until sunrise and go directly celebrate at Waffle House. For those wondering why I didn’t just head off to Waffle House then and there: I am happily married, and intend to keep it that way.

3:00 am emulation setup.

At that point my main work computer was connected via wired Ethernet to my switch, my switch to my router, and through there to my workstation.

And so there I was connected via ssh, running some physical implementation tests on my workstation, doing some small timing optimizations, when I decided that grabbing a swanky floorplan render would be a great addition to this ASIC’s documentation.

And so, I opened a GUI … (I know, who does that ?)

Thus, I was interfacing with the physical implementation tools over SSH, with visual forwarding enabled so I could see my floorplan results, and the results were unexpectedly … slow …

Like reaaaallllly slow … and laggy … and slow

I was contemplating my ssh visual lag until my two remaining brain cells reconnected and realized all my traffic was still being routed through the switch and that all the +9M packets that were composing my network traffic over the past few hours had been bottlenecked at 100 Mbps.

I was sleep deprived, your honor.

Turns out linux’s network management favors wired connections over wireless when available. So as soon as the switch became available all my ethernet traffic had stopped going over my wireless interface (wlp3s0) and was instead routed through my wired interface (enp2s0).

It turns out 100Mbps is enough for browsing reddit “the web” and Australia but not enough for ssh visual forwarding of ASIC floorplans.

At least we know one thing: it works! (Or at least, I think it works. )

The moment of truth will be around November 2026 when I get the chips back from the fab: let’s see if it stands up to being silicon proven.

The Coffee Shop family

For those not familiar with the term, “running a home lab” is the hobby of setting up and running a small datacenter tucked between the kitchen and the bedroom. It is also, as marriage counselors can attest to, a sign that the wife is a saint and that their marriage will be fine (allegedly).

Homelab [hom-læb]: a laboratory of (usually slightly outdated) awesome in the domicile.

The official ultimate authority on the question r/homelab

Robert’s very cool stealth homelab.

So it probably comes as no huge surprise that I have an interest in homelab’s.

But one humble switch doesn’t qualify as a homelab, no, there must be more, and it just so happens that there is.

This is actually part of a larger family of open source networking hardware IP that I have dubbed the “Coffee Shop” family.

It includes:

• coffeepot first generation switch.
• teapot Ethernet wrapper for building network connected accelerators.
• coldbrew Ethernet connected beacon for broadcasting an ethernet frame with an uptime count until the heat death of the universe.

And,since all of the ASICs mentioned above are already taped-out, in mid November when the silicon comes back I can start building my first fully custom homelab!

First generation custom home lab schematic, or how to take the term “custom” a bit too literally.

What is next ?

Obviously, the long-term plan is to replace my router, but before that, I first need to get this switch silicon proven, and then expand it with both more entries for the address resolution table and more ports. Right now, because of the Tiny Tapeout shuttle’s limitations, I can only fit three ports max. But if I move to a full chip, then I control all the pins! 🔥 w 🔥

A full chip would allow me to greatly bump my pin count to between 56 and 122 pins, giving me enough precious pins to make a much more respectable 8 ports switch chip.

I have been eyeing the wafer.space 0.5×1 slot so hard these days I might be starting to burn a hole through it. But alas, regrettably good practice requires having something silicon proven before blowing up the area budget.

At which point, my measly four entries for the address resolution table just are not going to cut it. To address that, I can either scale the number of entries up with more pure digital logic as I am doing now, or change paradigms entirely and move to the analog realm. Because in this beautiful land lives the mystical creature known for its low lookup latency and its far superior scaling prowess that is the content-addressable memory, or CAM for short. 🌈

Although realistically I could maybe scale up the number of entries with a pure digital approach a few more orders of twos, this would require significant additional logic complexity and would stretch my tight timing even more. But if I wanted say 64 entries or more, a CAM would be the way to go.

Closing words

So while I wait to get this first generation silicon back from the fab the next item on my TODO list is to expand my address table, potentially by building an analog content-addressable memory.

Meanwhile, some of my previous silicon has started coming back with the first-generation systolic array recently landing in my mailbox!

The devboard for the first Global Foundries experimental shuttle chip featuring my first generation systolic array accelerator, mentioned in the Two weeks until tapeout article has recently arrived. Hold on tight to your probes, it’s bring-up time !

But before any of that can start, there’s one tradition I will never miss out on!

Waffle House, but the waffles have already vanished. 🧇

At least that is where this story was supposed to end …

Round 2

wafer.space was started by Tim Ansell, also known as mithro online. The open source silicon community is actually really tiny, so we were acquainted.

So, while I was wrapping up this article, amused with my own typos, I sent him a small message.

And that is where he dropped the bombshell:

So you are telling me there is a chance ?

Recall Maslow’s pyramid from a few paragraphs back? Well scrap that, it’s not applicable when we are talking about the possibility of FREE AREA.

Now there is just one problem: we are not talking about just a single macro but doing a full chip here. Plus, I need to scale things up to actually make good use of the additional silicon and pins and I have nothing started to that effect.

Also, tapeout is in 4 days …

Welcome to round 2!

A design system for building faithful recreations of old UIs.

Intro

98.css is a CSS library for building interfaces that look like Windows 98. See more on GitHub.

My First VB4 Program

Hello, world!

OK Cancel

This library relies on the usage of semantic HTML. To make a button, you'll need to use a <button>. Input elements require labels. Icon buttons rely on aria-label. This page will guide you through that process, but accessibility is a primary goal of this project.

You can override many of the styles of your elements while maintaining the appearance provided by this library. Need more padding on your buttons? Go for it. Need to add some color to your input labels? Be our guest.

This library does not contain any JavaScript, it merely styles your HTML with some CSS. This means 98.css is compatible with your frontend framework of choice.

Here is an example of 98.css used with React, and an example with vanilla JavaScript. The fastest way to use 98.css is to import it from unpkg.

<link
  rel="stylesheet"
  href="https://unpkg.com/98.css"
>

You can install 98.css from the GitHub releases page, or from npm.

npm install 98.css

Components

Button

A command button, also referred to as a push button, is a control that causes the application to perform some action when the user clicks it.

— Microsoft Windows User Experience p. 160

A standard button measures 75px wide and 23px tall, with a raised outer and inner border. They are given 12px of horizontal padding by default.

Click me

<button>Click me</button>
<input type="submit" />
<input type="reset" />

You can add the class default to any button to apply additional styling, useful when communicating to the user what default action would happen in the active window if the Enter key was pressed on Windows 98.

OK

<button class="default">OK</button>

When buttons are clicked, the raised borders become sunken. The following button is simulated to be in the pressed (active) state.

I am being pressed

<button>I am being pressed</button>

Disabled buttons maintain the same raised border, but have a "washed out" appearance in their label.

I cannot be clicked

<button disabled>I cannot be clicked</button>

Button focus is communicated with a dotted border, set 4px within the contents of the button. The following example is simulated to be focused.

I am focused

<button>I am focused</button>

Checkbox

A check box represents an independent or non-exclusive choice.

— Microsoft Windows User Experience p. 167

Checkboxes are represented with a sunken panel, populated with a "check" icon when selected, next to a label indicating the choice.

Note: You must include a corresponding label after your checkbox, using the <label> element with a for attribute pointed at the id of your input. This ensures the checkbox is easy to use with assistive technologies, on top of ensuring a good user experience for all (navigating with the tab key, being able to click the entire label to select the box).

This is a checkbox

<input type="checkbox" id="example1">
<label for="example1">This is a checkbox</label>

Checkboxes can be selected and disabled with the standard checked and disabled attributes.

When grouping inputs, wrap each input in a container with the field-row class. This ensures a consistent spacing between inputs.

I am checked

I am inactive

I am inactive but still checked

<div class="field-row">
  <input checked type="checkbox" id="example2">
  <label for="example2">I am checked</label>
</div>
<div class="field-row">
  <input disabled type="checkbox" id="example3">
  <label for="example3">I am inactive</label>
</div>
<div class="field-row">
  <input checked disabled type="checkbox" id="example4">
  <label for="example4">I am inactive but still checked</label>
</div>

OptionButton

An option button, also referred to as a radio button, represents a single choice within a limited set of mutually exclusive choices. That is, the user can choose only one set of options.

— Microsoft Windows User Experience p. 164

Option buttons can be used via the radio type on an input element.

Option buttons can be grouped by specifying a shared name attribute on each input. Just as before: when grouping inputs, wrap each input in a container with the field-row class to ensure a consistent spacing between inputs.

Yes

No

<div class="field-row">
  <input id="radio5" type="radio" name="first-example">
  <label for="radio5">Yes</label>
</div>
<div class="field-row">
  <input id="radio6" type="radio" name="first-example">
  <label for="radio6">No</label>
</div>

Option buttons can also be checked and disabled with their corresponding HTML attributes.

Peanut butter should be smooth

I understand why people like crunchy peanut butter

Crunchy peanut butter is good

<div class="field-row">
  <input id="radio7" type="radio" name="second-example">
  <label for="radio7">Peanut butter should be smooth</label>
</div>
<div class="field-row">
  <input checked disabled id="radio8" type="radio" name="second-example">
  <label for="radio8">I understand why people like crunchy peanut butter</label>
</div>
<div class="field-row">
  <input disabled id="radio9" type="radio" name="second-example">
  <label for="radio9">Crunchy peanut butter is good</label>
</div>

GroupBox

A group box is a special control you can use to organize a set of controls. A group box is a rectangular frame with an optional label that surrounds a set of controls.

— Microsoft Windows User Experience p. 189

A group box can be used by wrapping your elements with the fieldset tag. It contains a sunken outer border and a raised inner border, resembling an engraved box around your controls.

Select one:

Diners

Drive-Ins

Dives

<fieldset>
  <div class="field-row">Select one:</div>
  <div class="field-row">
    <input id="radio10" type="radio" name="fieldset-example">
    <label for="radio10">Diners</label>
  </div>
  <div class="field-row">
    <input id="radio11" type="radio" name="fieldset-example">
    <label for="radio11">Drive-Ins</label>
  </div>
  <div class="field-row">
    <input id="radio12" type="radio" name="fieldset-example">
    <label for="radio12">Dives</label>
  </div>
</fieldset>

You can provide your group with a label by placing a legend element within the fieldset.

Today's mood

Claire Saffitz

Brad Leone

Chris Morocco

Carla Lalli Music

<fieldset>
  <legend>Today's mood</legend>
  <div class="field-row">
    <input id="radio13" type="radio" name="fieldset-example2">
    <label for="radio13">Claire Saffitz</label>
  </div>
  <div class="field-row">
    <input id="radio14" type="radio" name="fieldset-example2">
    <label for="radio14">Brad Leone</label>
  </div>
  <div class="field-row">
    <input id="radio15" type="radio" name="fieldset-example2">
    <label for="radio15">Chris Morocco</label>
  </div>
  <div class="field-row">
    <input id="radio16" type="radio" name="fieldset-example2">
    <label for="radio16">Carla Lalli Music</label>
  </div>
</fieldset>

TextBox

A text box (also referred to as an edit control) is a rectangular control where the user enters or edits text. It can be defined to support a single line or multiple lines of text.

— Microsoft Windows User Experience p. 181

Text boxes can rendered by specifying a text type on an input element. As with checkboxes and radio buttons, you should provide a corresponding label with a properly set for attribute, and wrap both in a container with the field-row class.

Occupation

<div class="field-row">
  <label for="text17">Occupation</label>
  <input id="text17" type="text" />
</div>

Additionally, you can make use of the field-row-stacked class to position your label above the input instead of beside it.

Address (Line 1)

Address (Line 2)

<div class="field-row-stacked" style="width: 200px">
  <label for="text18">Address (Line 1)</label>
  <input id="text18" type="text" />
</div>
<div class="field-row-stacked" style="width: 200px">
  <label for="text19">Address (Line 2)</label>
  <input id="text19" type="text" />
</div>

To support multiple lines in the user's input, use the textarea element instead.

Additional notes

<div class="field-row-stacked" style="width: 200px">
  <label for="text20">Additional notes</label>
  <textarea id="text20" rows="8"></textarea>
</div>

Text boxes can also be disabled and have value with their corresponding HTML attributes.

Favorite color

<div class="field-row">
  <label for="text21">Favorite color</label>
  <input id="text21" disabled type="text" value="Windows Green"/>
</div>

Slider

A slider, sometimes called a trackbar control, consists of a bar that defines the extent or range of the adjustment and an indicator that shows the current value for the control...

— Microsoft Windows User Experience p. 146

Sliders can rendered by specifying a range type on an input element.

Volume: Low High

<div class="field-row" style="width: 300px">
  <label for="range22">Volume:</label>
  <label for="range23">Low</label>
  <input id="range23" type="range" min="1" max="11" value="5" />
  <label for="range24">High</label>
</div>

You can make use of the has-box-indicator class replace the default indicator with a box indicator, furthermore the slider can be wrapped with a div using is-vertical to display the input vertically.

Note: To change the length of a vertical slider, the input width and div height.

Cowbell

<div class="field-row">
  <label for="range25">Cowbell</label>
  <div class="is-vertical">
    <input id="range25" class="has-box-indicator" type="range" min="1" max="3" step="1" value="2" />
  </div>
</div>

Dropdown

A drop-down list box allows the selection of only a single item from a list. In its closed state, the control displays the current value for the control. The user opens the list to change the value.

— Microsoft Windows User Experience p. 175

Dropdowns can be rendered by using the select and option elements.

5 - Incredible! 4 - Great! 3 - Pretty good 2 - Not so great 1 - Unfortunate

<select>
  <option>5 - Incredible!</option>
  <option>4 - Great!</option>
  <option>3 - Pretty good</option>
  <option>2 - Not so great</option>
  <option>1 - Unfortunate</option>
</select>

By default, the first option will be selected. You can change this by giving one of your option elements the selected attribute.

5 - Incredible! 4 - Great! 3 - Pretty good 2 - Not so great 1 - Unfortunate

<select>
  <option>5 - Incredible!</option>
  <option>4 - Great!</option>
  <option selected>3 - Pretty good</option>
  <option>2 - Not so great</option>
  <option>1 - Unfortunate</option>
</select>

Window

The following components illustrate how to build complete windows using 98.css.

Title Bar

At the top edge of the window, inside its border, is the title bar (also reffered to as the caption or caption bar), which extends across the width of the window. The title bar identifies the contents of the window.

— Microsoft Windows User Experience p. 118

Include command buttons associated with the common commands of the primary window in the title bar. These buttons act as shortcuts to specific window commands.

— Microsoft Windows User Experience p. 122

You can build a complete title bar by making use of three classes, title-bar, title-bar-text, and title-bar-controls.

A Title Bar

<div class="title-bar">
  <div class="title-bar-text">A Title Bar</div>
  <div class="title-bar-controls">
    <button aria-label="Close"></button>
  </div>
</div>

We make use of aria-label to render the Close button, to let assistive technologies know the intent of this button. You may also use "Minimize", "Maximize", "Restore" and "Help" like so:

A Title Bar

A Maximized Title Bar

A Helpful Bar

<div class="title-bar">
  <div class="title-bar-text">A Title Bar</div>
  <div class="title-bar-controls">
    <button aria-label="Minimize"></button>
    <button aria-label="Maximize"></button>
    <button aria-label="Close"></button>
  </div>
</div>

<br />

<div class="title-bar">
  <div class="title-bar-text">A Maximized Title Bar</div>
  <div class="title-bar-controls">
    <button aria-label="Minimize"></button>
    <button aria-label="Restore"></button>
    <button aria-label="Close"></button>
  </div>
</div>

<br />

<div class="title-bar">
  <div class="title-bar-text">A Helpful Bar</div>
  <div class="title-bar-controls">
    <button aria-label="Help"></button>
    <button aria-label="Close"></button>
  </div>
</div>

Each aria-label also has a corresponding styling class to render the title bar buttons, to let the aria-label text be in other languages without causing rendering, accessibility, or localization issues.

A Title Bar using Button Styling Classes

A Maximized Title Bar using Button Styling Classes

A Helpful Bar using Button Styling Classes

<div class="title-bar">
  <div class="title-bar-text">A Title Bar using Button Styling Classes</div>
  <div class="title-bar-controls">
    <button aria-label="Any Text" class="minimize"></button>
    <button aria-label="Any Text" class="maximize"></button>
    <button aria-label="Any Text" class="close"></button>
  </div>
</div>

<br />

<div class="title-bar">
  <div class="title-bar-text">A Maximized Title Bar using Button Styling Classes</div>
  <div class="title-bar-controls">
    <button aria-label="Any Text" class="minimize"></button>
    <button aria-label="Any Text" class="restore"></button>
    <button aria-label="Any Text" class="close"></button>
  </div>
</div>

<br />

<div class="title-bar">
  <div class="title-bar-text">A Helpful Bar using Button Styling Classes</div>
  <div class="title-bar-controls">
    <button aria-label="Any Text" class="help"></button>
    <button aria-label="Any Text" class="close"></button>
  </div>
</div>

Maximize buttons can be disabled, useful when making a window appear as if it cannot be maximized.

A Title Bar with Maximize disabled

<div class="title-bar">
  <div class="title-bar-text">A Title Bar with Maximize disabled</div>
  <div class="title-bar-controls">
    <button aria-label="Minimize"></button>
    <button aria-label="Maximize" disabled></button>
    <button aria-label="Close"></button>
  </div>
</div>

You can make a title bar "inactive" by adding inactive class, useful when making more than one window.

An inactive title bar

<div class="title-bar inactive">
  <div class="title-bar-text">An inactive title bar</div>
  <div class="title-bar-controls">
    <button aria-label="Close"></button>
  </div>
</div>

Window contents

Every window has a boundary that defines its shape.

— Microsoft Windows User Experience p. 118

To give our title bar a home, we make use of the window class. This provides a raised outer and inner border, as well as some padding. We can freely resize the window by specifying a width in the container style.

A Complete Window

<div class="window" style="width: 300px">
  <div class="title-bar">
    <div class="title-bar-text">A Complete Window</div>
    <div class="title-bar-controls">
      <button aria-label="Minimize"></button>
      <button aria-label="Maximize"></button>
      <button aria-label="Close"></button>
    </div>
  </div>
</div>

To draw the contents of the window, we use the window-body class under the title bar.

A Window With Stuff In It

There's so much room for activities!

<div class="window" style="width: 300px">
  <div class="title-bar">
    <div class="title-bar-text">A Window With Stuff In It</div>
    <div class="title-bar-controls">
      <button aria-label="Minimize"></button>
      <button aria-label="Maximize"></button>
      <button aria-label="Close"></button>
    </div>
  </div>
  <div class="window-body">
    <p>There's so much room for activities!</p>
  </div>
</div>

Status Bar

A status bar is a special area within a window, typically the bottom, that displays information about the current state of what is being viewed in the window or any other contextual information, such as keyboard state.

— Microsoft Windows User Experience p. 146

You can render a status bar with the status-bar class, and status-bar-field for every child text element.

A Window With A Status Bar

There are just so many possibilities:

• A Task Manager
• A Notepad
• Or even a File Explorer!

Press F1 for help

Slide 1

CPU Usage: 14%

<div class="window" style="width: 320px">
  <div class="title-bar">
    <div class="title-bar-text">A Window With A Status Bar</div>
  </div>
  <div class="window-body">
<p> There are just so many possibilities:</p>
<ul>
    <li>A Task Manager</li>
    <li>A Notepad</li>
    <li>Or even a File Explorer!</li>
</ul>
  </div>
  <div class="status-bar">
    <p class="status-bar-field">Press F1 for help</p>
    <p class="status-bar-field">Slide 1</p>
    <p class="status-bar-field">CPU Usage: 14%</p>
  </div>
</div>

TreeView

A tree view control is a special list box control that displays a set of objects as an indented outline based on their logical hierarchical relationship.

— Microsoft Windows User Experience p. 178

To render a tree view, use an ul element with the tree-view class. The children of this list (li elements), can contain whatever you'd like.

• We can put
• ✨ Whatever ✨
• We want in here

<ul class="tree-view">
  <li>We can put</li>
  <li><strong style="color: purple">✨ Whatever ✨</strong></li>
  <li>We want in here</li>
</ul>

To make this a tree, we can nest further ul elements (no class needed on these). This will provide them with a nice dotted border and indentation to illustrate the structure of the tree.

To create expandable sections, wrap child lists inside of details elements.

• Table of Contents

• What is web development?

• CSS

  • Selectors
  • Specificity
  • Properties

• JavaScript

  • Avoid at all costs

  • Unless

    • Avoid

    • At

      • Avoid
      • At
      • All
      • Cost

    • All

    • Cost

• HTML

• Special Thanks

<ul class="tree-view">
  <li>Table of Contents</li>
  <li>What is web development?</li>
  <li>
    CSS
    <ul>
      <li>Selectors</li>
      <li>Specificity</li>
      <li>Properties</li>
    </ul>
  </li>
  <li>
    <details open>
      <summary>JavaScript</summary>
      <ul>
        <li>Avoid at all costs</li>
        <li>
          <details>
            <summary>Unless</summary>
            <ul>
              <li>Avoid</li>
              <li>
                <details>
                  <summary>At</summary>
                  <ul>
                    <li>Avoid</li>
                    <li>At</li>
                    <li>All</li>
                    <li>Cost</li>
                  </ul>
                </details>
              </li>
              <li>All</li>
              <li>Cost</li>
            </ul>
          </details>
        </li>
      </ul>
    </details>
  </li>
  <li>HTML</li>
  <li>Special Thanks</li>
</ul>

Tabs

A tab control is analogous to a divider in a file cabinet or notebook. You can use this control to define multiple logical pages or sections of information within the same window.

— Microsoft Windows User Experience p. 193

To render a tab list, use a menu element with the [role=tablist] attribute. The children of this menu (li elements), should get a [role=tab] attribute.

Tabs should be managed by adding custom javascript code. All you need is to add the [aria-selected=true] attribute to the active tab.

Hello, world!

Desktop

My computer

Control panel

Devices manager

Hardware profiles

Performance

the tab content

<div class="window-body">
  <p>Hello, world!</p>

  <menu role="tablist">
    <li role="tab" aria-selected="true"><a href="#tabs">Desktop</a></li>
    <li role="tab"><a href="#tabs">My computer</a></li>
    <li role="tab"><a href="#tabs">Control panel</a></li>
    <li role="tab"><a href="#tabs">Devices manager</a></li>
    <li role="tab"><a href="#tabs">Hardware profiles</a></li>
    <li role="tab"><a href="#tabs">Performance</a></li>
  </menu>
  <div class="window" role="tabpanel">
    <div class="window-body">
      <p>the tab content</p>
    </div>
  </div>
</div>

To create multirows tabs, add a multirows class to the menu tag.

Hello, world!

Desktop

My computer

Control panel

Devices manager

Hardware profiles

Performance

Users

Network

Programs

Services

Resources

Advanced

the tab content

<div class="window-body">
  <p>Hello, world!</p>

  <menu role="tablist" class="multirows">
    <li role="tab"><a href="#tabs">Desktop</a></li>
    <li role="tab"><a href="#tabs">My computer</a></li>
    <li role="tab"><a href="#tabs">Control panel</a></li>
    <li role="tab"><a href="#tabs">Devices manager</a></li>
    <li role="tab"><a href="#tabs">Hardware profiles</a></li>
    <li role="tab"><a href="#tabs">Performance</a></li>
  </menu>
  <menu role="tablist" class="multirows">
    <li role="tab"><a href="#tabs">Users</a></li>
    <li role="tab"><a href="#tabs">Network</a></li>
    <li role="tab"><a href="#tabs">Programs</a></li>
    <li role="tab"><a href="#tabs">Services</a></li>
    <li role="tab"><a href="#tabs">Resources</a></li>
    <li role="tab"><a href="#tabs">Advanced</a></li>
  </menu>
  <div class="window" role="tabpanel">
    <div class="window-body">
      <p>the tab content</p>
    </div>
  </div>
</div>

TableView

To render a table view, use a table element. Wrap it with a div element with sunken-panel class to provide proper border and overflow container.

With a bit of extra scripting you can make table view interactive. Give interactive class to table element to show pointer cursor when hovering over body rows. Table rows can be given highlighted class to appear selected.

Name Version Company MySQL ODBC 3.51 Driver 3.51.11.00 MySQL AB SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation SQL Server 3.70.06.23 Microsoft Corporation

<div class="sunken-panel" style="height: 120px; width: 240px;">
  <table class="interactive">
    <thead>
      <tr>
        <th>Name</th>
        <th>Version</th>
        <th>Company</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>MySQL ODBC 3.51 Driver</td>
        <td>3.51.11.00</td>
        <td>MySQL AB</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
      <tr>
        <td>SQL Server</td>
        <td>3.70.06.23</td>
        <td>Microsoft Corporation</td>
      </tr>
    </tbody>
  </table>
</div>
<script>
  document.querySelectorAll('table.interactive').forEach(element => {
    element.addEventListener('click', (event) => {
      const highlightedClass = 'highlighted';
      const isRow = element => element.tagName === 'TR' && element.parentElement.tagName === 'TBODY';
      const newlySelectedRow = event.composedPath().find(isRow);
      const previouslySelectedRow = Array.from(newlySelectedRow.parentElement.children).filter(isRow).find(element => element.classList.contains(highlightedClass));
      if(previouslySelectedRow){
        previouslySelectedRow.classList.toggle(highlightedClass);
      }

      if (newlySelectedRow) {
        newlySelectedRow.classList.toggle(highlightedClass);
      }
    })
  });
</script>

Progress Indicator

You can use a progress indicator, also known as a progress bar control, to show the percentage of completion of a lengthy operation.

— Microsoft Windows User Experience p. 189

There are two types of progress bars: solid and segmented. The solid version is the default. To declare a segmented bar, you should use the segmented class.

<div class="progress-indicator">
  <span class="progress-indicator-bar"  style="width: 40%;" />
</div>

<div class="progress-indicator segmented">
  <span class="progress-indicator-bar" style="width: 40%;" />
</div>

Field borders

Text boxes, check boxes, drop-down list boxes, spin boxes and list boxes use the field border style. You can also use the style for define the work area within a window. It uses the sunken outer and sunken inner basic border styles. For most controls, the interior of the field uses the button highlight color. For text fields, such as text boxes and combo boxes, the interior uses the button face color when the field is read-only or disabled.

— Microsoft Windows User Experience p. 421

Status fields use the status field border style. This style uses only the sunken outer basic border style. You use the status field style in status bars and other read-only fields where the content of the file can change dynamically.

— Microsoft Windows User Experience p. 422

As mentioned in these guidelines, these styles are used in other contexts than just form elements and status fields such as to indicate work areas and dynamic content. For that reason, we provide three classes for these generic usages, field-border, field-border-disabled, and status-field-border. These classes only define the border and background color and minimal padding, so you will typically need to at least provide some extra padding yourself.

Work area

<div class="field-border" style="padding: 8px">
  Work area
</div>

Disabled work area

<div class="field-border-disabled" style="padding: 8px">
  Disabled work area
</div>

Dynamic content

<div class="status-field-border" style="padding: 8px">
  Dynamic content
</div>

Issues, Contributing, etc.

98.css is MIT licensed.

Refer to the GitHub issues page to see bugs in my CSS or report new ones. I'd really like to see your pull requests (especially those new to open-source!) and will happily provide code review. 98.css is a fun, silly project and I'd like to make it a fun place to build your open-source muscle.

Thank you for checking my little project out, I hope it brought you some joy today. Consider starring/following along on GitHub and maybe subscribing to more fun things on my twitter. 👋

Today, we are excited to announce a first version of the marimo plugin for PyCharm. You can now add reactive notebooks to your Python projects in PyCharm and other JetBrains IDEs.

PyCharm support has been one of our most requested features, both on our issue tracker and on JetBrains’ tracker. We’re starting with the full marimo editor and plan to improve the integration over time.

Check out the video:

A live notebook next to your code, in your IDE

With the plugin, you can add a marimo notebook to an existing project and import code from the application or library you are developing. You can use the notebook as a live workspace for testing your code or as an interactive demo for it, without leaving your IDE.

marimo’s module reloader updates the notebook cells as you update the imported Python modules. That gives you a tight feedback loop: edit your library code in PyCharm’s editor and see results in a reactive notebook.

Edit your library code and watch dependent notebook cells update automatically.

marimo notebooks are stored as plain .py files. The plugin identifies a notebook by looking for a marimo import and a matching App declaration, so ordinary Python files continue to open normally. You can switch between the marimo and Source tabs to move between the interactive notebook and native editor. Since marimo notebooks are plain Python files, they work really well with git (or any other VCS). You can use PyCharm VCS tools to version your notebooks alongside your project.

Opening a notebook file starts its local marimo server automatically and loads it in an editor tab. The plugin manages the port and process lifecycle, so there is no extra terminal or a separate browser tab to manage.

Keep your PyCharm workflow

By default, the plugin runs the notebook on your configured Python interpreter, so it uses the same environment and dependencies as your project. If marimo is not installed, the plugin offers to install it for you.

If you want to run the notebook without affecting your project environment, you can start a notebook in sandbox mode. Just choose the Start marimo in Sandbox option by right-clicking on the notebook file. This feature requires uv. With uv, marimo and the notebook dependencies run in an isolated environment; the dependencies are stored directly in the notebook using PEP 723 inline script metadata. The notebook remains self-contained and packages you install stay out of your project environment.

Your PyCharm tools stay available beside the notebook. For example, you can use PyCharm’s database tools to inspect schemas and query tables, then use the notebook to work with that data using Python or SQL.

Note: These tools work side by side rather than through a direct integration, so database connections need to be configured separately in marimo.

Pair with an agent

You can give your agent your marimo notebook with marimo-pair and jam on it together. The Pair with AI dropdown opens a PyCharm terminal and starts a marimo pair session with Claude, Codex, or opencode. You can also select Copy prompt and paste it into another agent, including Junie in PyCharm’s AI Chat.

Try it and help us with feedback

To try the plugin, install marimo from the JetBrains Marketplace, then create a marimo Notebook from the New menu or open an existing marimo .py file.

This is an early preview, and we’d love your feedback. Like marimo, the plugin itself is open source and available on GitHub. Share bugs and ideas in the plugin’s GitHub repository.