Server Mono and the return of the typewriter monospace

One weight, one oblique, and no bold in the family

Server Mono is a typeface released in 2024 by the Internet Development Studio Company of Seattle, Washington, created by Tim Vanhille and Matthieu Salvaggio with supplemental direction from Jimmy Lee and the studio community.

The first thing to understand about the family is its size. The documentation calls it a single-weight font, and the two CSS rules it ships are the regular weight and the oblique variant of that regular. There is no bold, no light, no condensed, no italic in the strict sense. The oblique is a slanted regular, which is how the typeface is built rather than a separate drawing.

That constraint shapes everything else about the project. A monospace family with one weight is a deliberate position, not an unfinished release: the design brief was a terminal face, where a single weight at a uniform width is the point, and where a bold weight would blur the edge of a character in a way that hurts a screen of dense output. The project describes the face in terms of clear readability and uniform character width, and places it in the tradition of monospace fonts used in command line interfaces.

The inspiration list is specific rather than generic: typewriters, Apple's San Francisco Mono, ASCII art, command line interfaces and programming tools. Those are five different references to the same idea, that a monospace face is a working surface rather than a reading face.

For a reader, the practical consequence is simple. If your design calls for weight contrast in code, you are expected to get it from colour or size rather than from a heavier cut, and if the design calls for a bold label next to a code sample, this family will not serve it.

The repository is a font project with a website attached

The repository holds two related things and it is worth knowing which is which, because they carry different licences.

The first is the source files for the typeface, under the `fonts/` directory, and the second is the source code for the project website, which is built with the studio's own next-sass-starter template system, the one used across all their websites. The top level layout shows the website side clearly: `app/`, `components/`, `modules/`, `common/`, `system/`, `public/`, `animations.scss`, `global.scss`, a `server-mono.css` file at the root, and a `package.json` and `tsconfig.json` for the Next.js app.

The website stack is current. The manifest depends on Next at `^16.2.10`, React and React DOM at `^19.2.7`, d3 at `^7.9.0` and sass at `1.94.2`, with TypeScript at `6.0.3` and Node `>=18` as the engine requirement. The dev script runs `next -p 10000` and the start script pins the same port, which is why the local instructions send you to port 10000 rather than the Next default.

The `public/` directory is the part that matters for a user of the font. It is where the built font files and the stylesheet live, and the `jsdelivr` field in the manifest points at `./server-mono.css`, which is what makes the CDN route work. That single field is the link between a font project and the distribution method.

The `fonts/` directory holds the design source, and `AUTHORS.TXT` and `CONTRIBUTORS.txt` record the people involved, listed in the readme as Tim Vanhille, Matthieu Salvaggio, Andrew Alimbuyuguen, Jimmy Lee, Whyrusleeping, Philip Bedford and Caidan Williams.

Two distribution routes, and the CDN one pins to a moving tag

There are three ways to get the font, and they are worth ranking by how much they commit you.

The first is the GitHub Releases page, which the documentation points to for the latest version. The second is Homebrew, with a cask named `font-server-mono`:

brew install --cask font-server-mono

The third is jsDelivr, and this is the one with a design decision embedded in it. The project states that Server Mono is also available through the jsDelivr CDN so that you can use the fonts without downloading and hosting them yourself. The pre-built stylesheet is served at a path that includes `@latest`.

That `@latest` is the part to look at. It means the CSS you link to will start pointing at a newer build the next time a release is published, without you changing anything. For a type that is stable and unlikely to change its metrics, that is a reasonable convenience. For a project where a font update can shift line breaks on a page you did not touch, it is a risk.

If you would rather not have that, the self hosted route is the alternative and it is well documented. You add the downloaded font files to your site's public or static directory, using a `/fonts/` prefix in the examples, and then copy the CSS rule into your stylesheet. The rule declares the family as `ServerMono` and lists three formats in one `src`, with `woff2` marked as best compression for modern browsers, `woff` for wider support, and `otf` as the largest file with universal support.

@font-face {
  font-family: 'ServerMono';
  src: url('/fonts/ServerMono-Regular.woff2') format('woff2'),    /* Best compression, modern browsers */
       url('/fonts/ServerMono-Regular.woff') format('woff'),      /* Good compression, wider support */
       url('/fonts/ServerMono-Regular.otf') format('opentype');   /* Largest files, universal support */
  font-weight: normal;
  font-style: normal;
  font-display: swap;
}

Self hosting also removes the third party request from your page, which matters if you care about that, and the `font-display: swap` value in both rules means text renders in a fallback while the font loads, so a slow font host does not block a first paint.

The CDN stylesheet is one link tag away

If you take the CDN route, the whole integration is two lines of HTML:

<link rel="preconnect" href="https://cdn.jsdelivr.net">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/internet-development/www-server-mono@latest/server-mono.css">

The `preconnect` line is the part worth understanding rather than copying. It opens the connection to jsDelivr before the stylesheet request is made, so the DNS lookup, TLS handshake and connection setup overlap with the rest of the page's resources instead of happening after the parser reaches the link. For a font, which is on the critical path for text rendering, that difference is measurable in the experience of the first render.

The stylesheet URL is served from the repository's root at the `@latest` tag, and the same `public/fonts` files are reachable individually if you want to reference a specific format yourself. The documentation also gives the full CSS rule pointing at the CDN URLs, with the same three format fallbacks and the same comments about compression and support, for the case where you want the font-face rule inline rather than a separate stylesheet.

Once the font is loaded, applying it is two more lines. The family is set on the root so it applies everywhere:

:root {
  font-family: 'ServerMono', monospace;
}

And the oblique is selected with a font style, set to either `oblique` or `italic`:

p {
  font-family: 'ServerMono', monospace;
  font-style: 'oblique';
}

The fallback in both rules is the generic `monospace`, which is the right choice here. A font stack that ends in a generic family rather than a specific one will not collapse to a different typeface of similar metrics when Server Mono is missing, which is what you want for a face where the spacing is part of the design.

Building the website locally is a two command affair on port 10000

The project also documents how to run its own site, which is a small but telling piece of information about how the studio works.

The instructions are for macOS. You clone the repository and then run the server:

npm install
npm run dev

The `dev` script is `next -p 10000`, so the site comes up at `http://localhost:10000` rather than the Next.js default of 3000. The port is fixed in both the dev and the start script, with the start script setting `PORT=10000` before `next start`, so the production path serves on the same port as development.

The dependency set explains what the site does. d3 is there, which is the charting library and fits a font project site that demonstrates glyph shapes, measurements and design decisions visually rather than showing specimen tables alone. sass handles the styling, and the presence of `animations.scss` and `global.scss` at the root suggests the site leans on motion to present the typeface.

The build and lint scripts are the standard ones, `next build` and `next lint`, and the manifest declares the package at version 0.1.0. The `jsdelivr` field points at the root stylesheet, as mentioned, which is the mechanism that publishes the font's CSS to the CDN rather than something the studio maintains by hand.

For a font user none of this is required. It is here because the repository is both the design source and the site, and the two are versioned together. That is a reasonable arrangement for a studio, and it also means the font files in `public/` are build output rather than the master artwork.

A single weight and an old release date are the two real constraints

Two limitations are worth stating plainly, and neither is a defect so much as a boundary.

The first is the weight range. A single weight with an oblique is enough for a code editor theme, a terminal or a technical document, and not enough for a design system that needs a bold label, a light caption and a display cut. Because the family has no bold, any request for `font-weight: 700` in CSS will be synthesised by the browser, which fakes a bold by smearing the regular outlines, and synthesised bold on a monospace is noticeably worse than a drawn one. If a design depends on weight contrast, this typeface cannot provide it.

The second is the release history. The releases are v0.0.7 on 2025-06-10, v0.0.8 on 2025-06-21 and v0.1.0 on 2025-07-13, and the typeface itself was released in 2024. The last push to the repository was on 2026-08-22. The repository is not archived, so there is work in it, but the version numbers have not moved beyond 0.1.0 and the published releases predate the last commit by more than a year.

That gap matters in one specific way, and it is the reason to self host rather than use the `@latest` CDN tag. If a change lands in the repository after v0.1.0, a CDN consumer following `@latest` sees it and a self hosted consumer does not, so the two can drift apart. Self hosting pins the exact files you copied into your own directory and gives you the version you tested.

The licensing position is clear and worth repeating because two licences appear. The font files are released under the SIL Open Font License, with the licence text at the root of the repository, and the website source in the same repository is under MIT. The font licence is the one that governs your use of the typeface, and OFL-1.1 is a permissive licence designed for exactly that kind of embedding and redistribution, subject to the reserved font name rules if you modify and rename a derivative.

Editorial conclusion

Server Mono fits a designer or developer who wants a monospace with more character than the system default, and who is content with one weight and one oblique. It is the wrong choice for body copy at small sizes, for any layout that needs a bold weight, and for anyone who cannot accept that the type has been in release since 2024 while the repository's last push was on 2026-08-22. Before you commit, check three things: which of the three formats your pipeline actually serves, whether the jsDelivr route is acceptable for your deployment model, and whether the single weight works in the size range you need, since the project describes the face as a single weight with an oblique and no bold. The fonts are under the OFL, while the website source in the same repository is MIT.

Frequently asked questions

Official sources

1. internet-development/www-server-mono on GitHub
2. License: OFL-1.1
3. Project website
4. README
5. Releases