freshtomato.org

FreshTomato only supports routers built on Broadcom chipsets. If your router uses a Qualcomm, MediaTek, Realtek, or other non-Broadcom platform, it is not a candidate, regardless of how similar the model name looks. The authoritative compatibility list is the Supported Routers page on freshtomato.org — check your exact model and hardware revision there before downloading anything.

The one hard requirement: Broadcom silicon

The project describes itself as "a system based on Linux, dedicated for routers with Broadcom chipset." That single sentence rules out most consumer routers on the market, since Broadcom is only one of several common router SoC vendors.

Practical consequences:

• A router from a brand that sometimes ships Broadcom (ASUS, Netgear, Linksys, Tenda) is not automatically supported — the specific model and revision matter.
• A router from a brand that never ships Broadcom is not supported at all.
• Identical retail model names can ship with different chipsets across production runs, so the model number alone is not enough.

How to verify your router

1. Find your exact model and hardware version. This is printed on the label on the bottom or back of the device, and is also visible in the stock firmware's status page. Look for a version suffix (e.g. v1, v2, v3) — these often correspond to different chipsets.
2. Open the Supported Routers page on freshtomato.org and search for that exact model string.
3. Confirm the hardware revision matches, not just the model family.
4. Check flash and RAM capacity for the build you intend to install. Firmware images differ in size, and a model with small flash may only accept a trimmed build or none at all.
5. Download only from the official Download page, and match the image to your model — flashing an image built for a different revision is the most common way to brick a device.

If your model does not appear on the list, treat it as unsupported. Absence from the list is not an invitation to try a similar-looking build.

What you get once a model is supported

The feature set is the reason people seek out compatible hardware. According to the project's own feature summary, FreshTomato includes:

Note the ARM qualifier on WireGuard with PBR — on older MIPS-based Broadcom routers, that specific combination is not available. This is a good example of why the per-model list matters more than the headline feature list.

Common ways people get this wrong

• Buying by brand reputation. "Netgear supports Tomato" is not a usable rule. Only the model-and-revision entry is.
• Assuming a newer revision is supported. Vendors frequently swap chipsets mid-lifecycle to cut costs; a v3 may be unsupported while v1 and v2 are fine.
• Confusing FreshTomato with other Tomato forks. Builds, supported hardware, and maintenance status differ between forks. A model supported by one fork is not necessarily supported here.
• Skipping the capacity check. Even on a supported chipset, insufficient flash or RAM can mean no usable build exists for your unit.

Bottom line

Check the Supported Routers page on freshtomato.org against your router's exact model and hardware revision. If it matches, and the flash/RAM capacity fits the build, you can proceed to the Download page. If it does not match, the router is not supported — no workaround changes that, because the limitation is the chipset itself.

An open-source UI element library is a collection of individual, ready-made interface pieces—buttons, cards, inputs, toggles, loaders—that you copy into your own project and adapt. A UI framework, by contrast, is a structured system of components, conventions, and often a theming layer that governs how your whole interface is built. The practical difference: an element library gives you a snippet; a framework gives you a way of working. If you need a polished button in ten minutes, reach for the element library. If you're building a 40-screen product with a team, you probably want the framework.

What "open-source UI element library" actually means

The term gets used loosely, so it helps to separate the parts:

• Open-source: the code is publicly available, and the license tells you what you may do with it—copy, modify, redistribute, or use commercially.
• UI element: a single, self-contained piece of interface, usually small enough to read in one sitting. A button with hover states, a pricing card, a search field.
• Library: a browsable, searchable collection of those elements, typically contributed by many different people.

On a site like Uiverse, elements are shared by a community and written in plain CSS or Tailwind. You find one you like, copy the markup and styles, paste them into your project, and adjust colors, spacing, and text to fit. There's no package to install and no build step required—which is exactly the appeal, and also the source of most of the confusion.

Element library vs. UI framework: the core differences

The table isn't a verdict. It's a map of trade-offs. Element libraries win on speed and freedom; frameworks win on consistency and maintenance.

Licensing and attribution: what to check before you paste

This is where people get into trouble, and it's worth slowing down for.

1. Find the license. Every element or collection should state one. Common open-source licenses include MIT, Apache-2.0, and BSD. Some projects use copyleft licenses like GPL, which can impose obligations if you redistribute your code.
2. Understand what the license permits. MIT and Apache-2.0 are permissive: you can typically use the code in commercial and closed-source projects. Copyleft licenses may require you to release derivative source under the same terms.
3. Check attribution requirements. Permissive licenses usually require you to keep the copyright notice and license text somewhere in your project. That's a real obligation, not a formality.
4. Look for per-element terms. On community sites, the site's overall terms and the individual contributor's stated wishes may differ. If a contributor asks for credit, honor it.
5. When in doubt, ask or avoid. If a snippet has no license at all, you don't have clear permission to reuse it. Treat "no license" as "not open source," even if the code is publicly visible.

This article is general information, not legal advice. For commercial products with real exposure, have someone qualified review the licenses you're relying on.

How to use a community element in your project: a practical workflow

Here's a repeatable process that avoids most of the usual mess.

1. Start from a real need, not a browsing session

Decide what you need first—"a compact primary button with a loading state"—then search. Browsing aimlessly produces a pile of pretty snippets that don't fit together.

2. Copy the smallest version that works

Take the markup and the styles. Strip anything you don't need: demo wrappers, extra animations, decorative layers. Less code means fewer surprises.

3. Convert it to your conventions

If your project uses design tokens or CSS variables, replace hard-coded values:

/* Before: hard-coded */
.button { background: #4f46e5; border-radius: 8px; }

/* After: token-based */
.button { background: var(--color-primary); border-radius: var(--radius-md); }

This one step is what keeps a copied element from looking like a foreign object in your UI.

4. Check accessibility before you ship

Community elements vary widely here. Verify at minimum:

• Keyboard focus is visible and the element is reachable by Tab.
• Color contrast meets WCAG AA (4.5:1 for normal text).
• Interactive elements use semantic HTML (<button>, not a clickable <div>).
• Form inputs have associated labels.
• Motion respects prefers-reduced-motion.

5. Test in context

Paste it into a real page with real content. Long labels, small screens, and dark mode break more copied elements than anything else.

6. Note where it came from

Keep a short comment or an internal credits file: source, license, date. Future you—and your legal reviewer—will be grateful.

Where element libraries genuinely shine

• Prototypes and demos: you need something clickable today, not a design system.
• Landing pages and marketing sites: a handful of distinctive elements, each custom.
• Filling gaps: your framework lacks one specific component, and you don't want to build it from scratch.
• Learning: reading well-made CSS is one of the fastest ways to improve.
• Small projects: a personal site doesn't need a theming architecture.

Where they fall short

• Consistency at scale: ten elements from ten contributors rarely look like one product.
• Maintenance: you own every copy. When your design changes, you edit each one.
• Accessibility debt: you inherit whatever the contributor did or didn't do.
• No upstream fixes: a bug fixed in the original won't reach your copy.
• Integration friction: different naming conventions, different units, different assumptions about resets.

When to choose which

Choose an element library when the scope is small, the timeline is short, or you need a few distinctive pieces rather than a whole system.

Choose a framework or design system when multiple people build multiple screens over months, when consistency is a product requirement, or when accessibility and theming need to be guaranteed rather than checked.

A hybrid works well for many teams: adopt a framework for the structural components—forms, navigation, layout—and borrow individual elements for the places where you want personality. Just route every borrowed element through the same token and accessibility checks, so it lands as part of your system rather than beside it.

The short version: open-source UI element libraries are a fast, flexible way to get good-looking interface pieces into a project. They are not a substitute for a design system, and the license and accessibility details are the part worth reading carefully.

FreshTomato's official site, freshtomato.org, is the single entry point for all official resources: the Download page for firmware images, the Wiki for installation and configuration documentation, and Source Code for the GPL-licensed source. Before downloading anything, confirm your router is on the Supported Routers list — FreshTomato is built only for routers with a Broadcom chipset.

Official resource pages

Current release

The site lists the current release as 2026.4 (2026.09.14). Treat that version number as the reference point when you go to the Download page — if a file you find elsewhere shows a different version, it is not the current official build.

Before you download: check your router first

FreshTomato is a Linux-based system for routers with a Broadcom chipset, distributed under the GPL license. That constraint drives the whole process:

1. Open Supported Routers and find your exact model.
2. If your model is listed, go to Download and get the build matching that model.
3. If it is not listed, do not flash — the firmware is not built for that hardware.

The model matters because firmware images are hardware-specific; a build for one router is not interchangeable with another even within the same brand.

Documentation and source

• Wiki — the place to start for installation steps and configuration guidance. Read it before flashing, not after.
• Source Code — the project's GPL source, for anyone who wants to inspect, build, or modify it.
• Useful snippets — practical configuration examples you can adapt rather than write from scratch.
• Features — the authoritative list of what the firmware does, including full WireGuard support with PBR (ARM), bandwidth monitoring, advanced QoS, access control, SSH/Telnet, configurable buttons and LEDs, multiple wireless modes, a built-in OpenVPN server/client, SNMP, IP/MAC bandwidth limiting, and ARP binding.

Common sticking points

• Downloading before checking compatibility. The Supported Routers page is the gate, not an optional extra.
• Assuming one image fits all. Match the build to your specific model.
• Skipping the Wiki. Installation and recovery details live there; the Download page only hands you the file.

The site also links to a Donations page and lists a Bitcoin address for project support — separate from anything you need to download or install.

FreshTomato is an open-source, Linux-based firmware for routers with Broadcom chipsets, distributed under the GPL license. Its feature set centers on VPN support, traffic control, and network management that stock firmware typically omits or limits. The features below are the ones the project lists on its official site, so they apply to supported Broadcom-based routers running a current FreshTomato release.

VPN and tunneling

• Full WireGuard support with PBR (ARM) — Policy-Based Routing lets you send only selected clients or traffic through the WireGuard tunnel while the rest uses the normal WAN path. The ARM qualifier matters: this full implementation is tied to ARM-based builds, so check your router's architecture before assuming it applies.
• Built-in OpenVPN server/client — The firmware can act as either end of an OpenVPN connection, so you can run a VPN server on the router for remote access or use the router as a client to route your LAN through a commercial or self-hosted VPN.

Traffic control and monitoring

• Bandwidth monitoring — Tracks usage so you can see which clients or interfaces are consuming bandwidth over time.
• Advanced QoS — Prioritizes traffic classes rather than treating all packets equally, useful when one device's downloads would otherwise degrade calls or gaming.
• IP/MAC BW Limiter — Caps bandwidth per IP or MAC address, a per-device alternative to global QoS rules.
• ARP Binding — Pins IP-to-MAC mappings, which helps prevent ARP spoofing on your local network and keeps address assignments stable.

Access and administration

• Access control — Restricts which clients can reach the network or the internet on a schedule or by rule.
• Enabled SSH/Telnet protocols — Command-line access to the router for scripting and diagnostics beyond the web interface.
• SNMP protocol — Exposes router statistics to standard network monitoring tools, so FreshTomato devices can be folded into an existing monitoring setup.

Hardware and wireless options

• Configurable buttons and LEDs — You can remap the physical buttons and indicator lights on the router to trigger scripts or reflect custom states.
• Support for many wireless modes — Covers common operating modes (such as access point, client, and bridge-style configurations) rather than locking the radio to a single role.

How to decide whether it fits

The main constraint is hardware: FreshTomato targets Broadcom-chipset routers, so confirm your exact model appears in the project's supported routers list and that a current build exists for it before flashing. If your router uses a different chipset, the feature list above is not reachable through this firmware.

Only if your router uses a Broadcom chipset and you want capabilities your stock firmware does not expose — WireGuard with policy-based routing, advanced QoS, bandwidth monitoring, an OpenVPN server/client, SSH/Telnet access, and configurable buttons and LEDs. If your router is not Broadcom-based, FreshTomato is not an option at all, and the decision ends there. If it is, the trade-off is real: you gain an open-source, GPL-licensed Linux system with a friendly web interface, and you give up whatever vendor conveniences and warranty coverage your stock firmware provides.

What FreshTomato actually is

FreshTomato is an alternative open-source firmware for Broadcom-based routers, distributed under the GPL license and built on Linux. The project describes its interface as particularly friendly, to the point that even inexperienced users can work with it. It is not a general-purpose router OS for any hardware — the Broadcom chipset requirement is the first filter.

What you gain

The feature list on the official site is the practical case for switching:

• Full WireGuard support with PBR (ARM) — policy-based routing lets you send only selected traffic through the tunnel rather than everything.
• Built-in OpenVPN server/client — run the router as a VPN endpoint in either direction.
• Advanced QoS — prioritize traffic by type or client.
• Bandwidth monitoring — see who is using what.
• IP/MAC BW Limiter and ARP Binding — per-device bandwidth caps and address binding.
• Access control — restrict what devices can reach.
• Enabled SSH/Telnet protocols — command-line access for scripting and diagnostics.
• Support for many wireless modes — use the radio in configurations stock firmware may not offer.
• Configurable buttons and LEDs — repurpose physical controls and indicator lights.
• SNMP protocol — integrate with network monitoring tools.

If several of these matter to you, the switch is worth investigating. If none do, stock firmware is the lower-effort choice.

What you give up or take on

• Hardware restriction. Broadcom chipset only. Check the Supported Routers list before anything else.
• Flashing risk. Replacing firmware is a manual procedure with a real chance of leaving the router unusable if interrupted or mismatched. The project points you to its Wiki and Supported Routers pages for a reason — confirm your exact model and revision first.
• Vendor ecosystem. Stock firmware often bundles cloud management, app control, or vendor support channels. FreshTomato is a community project; the site lists Donations and Contact rather than a support contract.
• Your own troubleshooting. SSH/Telnet access and deep configurability mean you are the administrator. That is the appeal and the cost.

How to decide

Before you flash

1. Identify your router's exact model and hardware revision.
2. Check it against the Supported Routers page on freshtomato.org.
3. Read the Wiki for the installation procedure for your model.
4. Download the correct build from the Download page — the site lists Current Release 2026.4 (2026.09.14).
5. Confirm you have a recovery path if the flash fails.

The project also publishes Screenshots, Useful snippets, Source Code, Themes, and a TomatoAnon Database, which are useful for judging the interface and community activity before committing.