diff --git a/web/apps/web/app/resources/blog/[slug]/page.tsx b/web/apps/web/app/resources/blog/[slug]/page.tsx
new file mode 100644
index 000000000..508da8a3b
--- /dev/null
+++ b/web/apps/web/app/resources/blog/[slug]/page.tsx
@@ -0,0 +1,93 @@
+import { Badge, Eyebrow, Prose, Section } from "@nativelink/ui";
+import { marked } from "marked";
+import { notFound } from "next/navigation";
+import { formatPostDate, getAllPosts, getPost } from "../../../../lib/posts";
+
+export function generateStaticParams() {
+ return getAllPosts().map((post) => ({ slug: post.slug }));
+}
+
+export async function generateMetadata({
+ params,
+}: {
+ params: Promise<{ slug: string }>;
+}) {
+ const post = getPost((await params).slug);
+ if (!post) return {};
+ return {
+ title: post.title,
+ description: post.excerpt,
+ openGraph: {
+ title: post.title,
+ description: post.excerpt,
+ type: "article",
+ ...(post.image ? { images: [{ url: post.image }] } : {}),
+ },
+ };
+}
+
+export default async function BlogPostPage({
+ params,
+}: {
+ params: Promise<{ slug: string }>;
+}) {
+ const post = getPost((await params).slug);
+ if (!post) notFound();
+
+ const html = marked.parse(post.body, { async: false });
+
+ return (
+ <>
+
+
+
+
+
+ ← All posts
+
+
+ {post.tags.map((tag) => (
+
+ {tag}
+
+ ))}
+
+
+ {post.title}
+
+
+ {formatPostDate(post.pubDate)}
+ {post.readTime ? ` · ${post.readTime}` : null}
+
+
+
Blog
+
+ Writing from the team
+
+
+ Tutorials, case studies, and announcements from the people building NativeLink.
+
+
- Case studies, conference talks, and write-ups from the team building
- NativeLink — plus highlights from the broader community.
+ Case studies, conference talks, and write-ups from the team building NativeLink —
+ plus highlights from the broader community.
@@ -85,7 +90,10 @@ export default function ResourcesPage() {
Read the write-up{" "}
-
+
→
@@ -120,74 +128,32 @@ export default function ResourcesPage() {
- {/* ANNOUNCEMENTS + VIDEO */}
-
-
-
-
-
-
+ {/* FROM THE TEAM — full blog listing */}
+
+
-
-
-
-
-
- Featured talk ·{" "}
-
- Hermetic Toolchain Creation with Local Remote Execution & Nix
-
-
- Aaron Mondal, Trace Machina — 32 min
-
+
+ From the team
+
+
-
-
+
+ {card.tags.map((tag) => (
+
+ {tag}
+
+ ))}
+ {card.meta}
+
+
+ {card.title}
+
+
{card.excerpt}
+
+ {card.cta}{" "}
+
+ →
+
+
+
+
+ );
+}
+
+export function PostSection({
+ title,
+ cards,
+ className,
+}: {
+ title: string;
+ cards: PostCardData[];
+ className?: string;
+}) {
+ if (cards.length === 0) {
+ return null;
+ }
+ return (
+
+
+ {title}
+
+
+ {cards.map((card, i) => (
+
+ ))}
+
+1\. **Bazel Build System**: For efficient repository management. A repository managed by Bazel allows your team to work in a unified codebase while maintaining clean separation of concerns.
+2\. **NativeLink**: A remote execution system hosted in your cloud. With NativeLink's remote execution capabilities, you can leverage your cloud resources optimally without wasteful duplication of work.
+3\. **Hugging Face Transformers**: For integrating with the rich ecosystem of open-source models that you can run locally or deploy anywhere. The transformers library also provides a sophisticated caching mechanism for optimizing loading model weights.
+
+
+## Setting Up Your Repository With Bazel
+
+Bazel is a build system designed for repositories that allows you to organize code into logical components while maintaining dependency relationships. For AI workloads, this is particularly valuable as it lets you separate model definitions, data processing pipelines, training code, and inference services.
+
+### Prerequisites
+
+1\. A recent version of Bazel ([installation instructions](https://bazel.build/install)).
+2\. [NativeLink 0.6.0](https://github.com/TraceMachina/nativelink/releases/tag/v0.6.0) (Apache-licensed)
+
+### Initial Setup
+
+First, let's download all the files. From the folder where you want to download the files, run the following commands:
+
+
+
+```bash
+# Clone the entire repository
+git clone https://github.com/TraceMachina/nativelink-blogs.git
+
+# Navigate to the subdirectory
+cd nativelink-blogs/finetuning_on_cpu
+```
+
+
+
+Here's a description of some of the files:
+1\. `README.md` - Instructions on how to connect/use NativeLink Cloud and how to run the code locally as well as remotely
+2\. `requirements.lock` - Ensures consistent Python dependencies across all environments
+3\. `.bazelrc` - Main Bazel configuration file setting global options for hermetic builds and remote execution
+4\. `MODULE.bazel` - Configures the project as a Bazel module, tells Bazel we'll need Python, `pip` and CPU-only PyTorch, and manages external dependencies
+5\. `pyproject.toml` - Python package configuration specifying dependencies and development tools
+6\. `BUILD.bazel` (root) - Root build file defining lock targets for Python dependency management
+7\. `platforms/BUILD` - Defines Linux x86_64 execution platform running in Ubuntu 24.04 for remote builds
+8\. `training/BUILD` - Defines the model training targets and their dependencies
+9\. `training/main.py` - Main script that handles fine-tuning of language models on CPU using efficient training techniques
+
+
+## Important Note About Bazel’s Remote Execution Support
+
+Bazel supports remote execution for building (compiling) and testing, but `bazel run` uses the host platform as its target platform, meaning the executable will be invoked locally rather than on remote machines. To execute binaries on remote servers, a workaround is to design tests that execute the binary, effectively leveraging `bazel test` which runs on the target platform.
+
+**DRAWBACK:**
+
+Logging and print statements that track progress (like "Starting to fine tune model" or "Exiting this function") behave differently in remote execution. Unlike local runs where these appear in real-time, remote testing collects all logs on the server and only displays them after test completion when control returns to the local machine. The expected output is still fully preserved - just delayed until the process finishes running.
+
+
+## Aside - Configuring Remote Execution For ARM (Apple Silicon)
+
+
+Most cloud infrastructure (including NativeLink) runs on x86_64 processors, while Apple Silicon Macs use ARM64. Dependencies such as PyTorch are built for specified architectures and setting up Bazel to handle platform-specific dependencies is complex.
+
+If you want to run this code and you only have a Mac, the simplest way would be to run this code via a cloud-based Linux VM (GCP/AWS). If you don't want to use a cloud server, you could create a minimal docker container for x86_64 (`FROM --platform=linux/amd64 ubuntu:24.04` with just `curl` and `Bazelisk` installed) with **Rosetta enabled** and run from your Mac's terminal using this container. However, we highly recommend against this approach; the correct approach here would be to use toolchain transitions from a local mac platform to the remote Linux runner, but that's outside of the scope of this article.
+
+
+## The NativeLink Difference
+
+To demonstrate NativeLink’s efficacy, consistency, and reliability, we ran the same fine-tuning job on the CPU of an M1 Pro MacBook Pro, the free version of Google Colab on CPU, and [NativeLink](https://github.com/TraceMachina/nativelink), which is free and open-source. We executed the fine-tuning task 5 times and this is what we observed:
+
+1\. The Mac: the quickest run took 18 minutes while the slowest/longest took 20 minutes
+
+2\. Free version of Google Colab: the quickest run took 10 minutes while the slowest/longest took 20 minutes. The execution time was widely varied. We suspect varying traffic on Google’s servers and how Colab allocates its compute resources played a part in this variability.
+
+3\. Free NativeLink: the quickest run took 4 minutes of compute time while the slowest/longest took 6 minutes. NativeLink Cloud provided the quickest execution times by far.
+
+
+
+
+## Conclusion: Optimizing AI Development Through Resource Efficiency
+
+As demonstrated through this tutorial, the integration of Bazel's repository management, NativeLink's CPU-optimized remote execution, and Hugging Face's transformers library creates a development ecosystem that prioritizes computational efficiency over raw processing power. This approach addresses several critical challenges facing modern AI teams:
+
+1\. **Resource Optimization**: By leveraging NativeLink's intelligent scheduling and optimization on CPU infrastructure, teams can achieve impressive fine-tuning results without the capital expenditure of specialized GPU/TPU hardware.
+2\. **Strategic Advantage**: This CPU-focused approach provides a competitive edge through efficient resource utilization, enabling teams to allocate budget toward innovation rather than hardware acquisition.
+3\. **Sustainable Scaling**: As models grow in size and complexity, the ability to efficiently distribute workloads across existing CPU infrastructure provides a more sustainable path to scale than continuously upgrading to the latest accelerators.
+
+For forward-thinking AI teams, this infrastructure stack represents a shift from the "bigger is better" hardware arms race toward thoughtful resource utilization. The competitive advantage increasingly belongs to those who can extract maximum value from available compute rather than those who deploy more powerful hardware.
+
+The journey from experimental AI projects to production-grade systems demands both technical sophistication and resource awareness. By adopting this CPU-optimized approach with Bazel and NativeLink, your team can focus less on infrastructure limitations and more on the creative potential of fine-tuned models—developing applications that deliver genuine value while maintaining computational efficiency.
diff --git a/web/apps/web/content/posts/NativeLink_for_Semiconductors.md b/web/apps/web/content/posts/NativeLink_for_Semiconductors.md
new file mode 100644
index 000000000..073796898
--- /dev/null
+++ b/web/apps/web/content/posts/NativeLink_for_Semiconductors.md
@@ -0,0 +1,39 @@
+---
+title: "NativeLink for Semiconductors"
+tags: ["news", "blog-posts"]
+image: https://www.gstatic.com/webp/gallery/4.sm.webp
+slug: semiconductors
+pubDate: 2024-12-04
+readTime: 4 minutes
+---
+## Open Source: Enabling the Performance and Deterministic Builds for the Next Era of Semiconductor Innovation
+
+### **Transforming Semiconductor Design with NativeLink**
+
+NativeLink has become a critical architectural component for companies developing custom silicon. From the outset, our mission was to build an open-source simulation platform designed to scale with cutting-edge client technologies and cater to the needs of pioneering industries like autonomous robotics. These innovators have increasingly sought alternatives to proprietary solutions for design simulation, leveraging NativeLink for direct hardware access, no garbage collection, considerable infrastructure cost reduction, and high-fidelity test environments. And now, with the proliferation of large language models (LLMs) and Nvidia’s monopolistic dominance in advanced computing, NativeLink has garnered significant interest from an unexpected sector: semiconductors.
+
+This shift is fueled by the proliferation of large language models (LLMs) and Nvidia's dominance in advanced computing, which have driven the development of new semiconductor technologies aimed at addressing supply-side challenges. Among the most promising advancements driving the development of new semiconductor technologies are:
+
+1. **Simplified Silicon Architectures**, streamlining traditional designs for efficiency and scalability.
+2. **Diamond Wafers**, leveraging superior thermal and electrical properties.
+3. **Nanophotonic Metamaterials**, pioneering optical solutions for enhanced performance.
+
+While these innovations hold transformative potential across industries from computing to healthcare, the legacy tools dominating electronic design automation (EDA)—such as Cadence, Ansys, and Synopsys—have anchored the space as billion-dollar leaders in EDA, ripe for smaller but hopefully valuable new integrations with their established, proprietary workflows.
+
+### **Open Silicon: Bridging the Gap with Open Source**
+
+The rising demand for compute power has outpaced the silicon industry's ability to deliver. To address this, Google developed the "Open Silicon" strategy, incorporating open-source technologies such as LLVM, XLS, OpenRoad, and Bazel. The traditional silicon design workflow—spanning RTL design, synthesis, and place-and-route—has historically relied on disparate, proprietary tools, creating inefficiencies in iteration and maintenance.
+
+By integrating these workflows into a Bazel-managed ecosystem, NativeLink enables a streamlined, deterministic approach. Using Bazel build rules written in Starlark, users can manage each design stage as version-controlled code within a monorepo, leveraging open-source tools for greater transparency, customizability, and collaboration.
+
+### **Deterministic Execution with Rust and Nix**
+
+NativeLink’s Rust foundation ensures reliability by minimizing race conditions, which are often identified at compile time. Coupled with Nix as a dependency manager, the platform provides a hermetic environment with fine-grained control over pinned dependencies. This approach contrasts with many legacy tools and emerging competitors that rely on garbage-collected languages, introducing nondeterministic behavior.
+
+### **A New Era of Open-Source EDA**
+
+Open-source tools such as Verilog, Bazel, Verilator, `rules_hdl`, and OpenRoad have set the stage for a new generation of silicon providers. RISC-V is new and not for everyone, but it's a glimpse into the opening world of semiconductors. By adopting an open source, instruction set architecture, companies can eliminate licensing fees and leverage modular design benefits. NativeLink furthers this modularity, breaking each system component into self-contained modules that foster maintainability and extensibility. For more details, [explore our GitHub repository](https://github.com/TraceMachina/nativelink).
+
+### **The Future of Semiconductor Innovation**
+
+NativeLink’s remote execution and caching capabilities are expanding rapidly, empowering innovators to explore the potential of open-source tools in semiconductor design. As industries push the boundaries of technology, we're committed to enabling breakthroughs with flexible, scalable, and deterministic infrastructure tools that engineers can rely on.
diff --git a/web/apps/web/lib/posts.ts b/web/apps/web/lib/posts.ts
new file mode 100644
index 000000000..4d9241839
--- /dev/null
+++ b/web/apps/web/lib/posts.ts
@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export interface Post {
+ slug: string;
+ title: string;
+ tags: string[];
+ image?: string;
+ pubDate: string;
+ readTime?: string;
+ excerpt: string;
+ body: string;
+}
+
+const POSTS_DIR = path.join(process.cwd(), "content/posts");
+
+// The restored posts (recovered from the pre-redesign Astro site) all share
+// the same flat frontmatter shape, so a full YAML parser isn't needed:
+// title: "..." tags: [".."] image: url slug: str pubDate: date readTime: str
+function parseFrontmatter(raw: string): {
+ data: Record;
+ body: string;
+} {
+ const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+ if (!match || match[1] === undefined) return { data: {}, body: raw };
+ const data: Record = {};
+ for (const line of match[1].split(/\r?\n/)) {
+ const kv = line.match(/^([A-Za-z]+):\s*(.*)$/);
+ const key = kv?.[1];
+ if (!kv || key === undefined || kv[2] === undefined) continue;
+ const value = kv[2].trim();
+ if (value.startsWith("[")) {
+ data[key] = value
+ .replace(/^\[|\]$/g, "")
+ .split(",")
+ .map((v) => v.trim().replace(/^["']|["']$/g, ""))
+ .filter(Boolean);
+ } else {
+ data[key] = value.replace(/^["']|["']$/g, "");
+ }
+ }
+ return { data, body: raw.slice(match[0].length) };
+}
+
+function deriveExcerpt(body: string): string {
+ for (const block of body.split(/\r?\n\r?\n/)) {
+ let text = block
+ .replace(/^#+\s.*$/gm, "")
+ .replace(/^-{3,}\s*$/gm, "")
+ .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
+ .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")
+ .replace(/[*_`>]/g, "");
+ // Strip HTML tags to a fixpoint so overlapping fragments can't
+ // reassemble into a tag after a single pass.
+ let previous: string;
+ do {
+ previous = text;
+ text = text.replace(/<[^>]*>/g, "");
+ } while (text !== previous);
+ text = text.replace(/\s+/g, " ").trim();
+ if (text.length > 60) {
+ return text.length > 200 ? `${text.slice(0, 197).trimEnd()}…` : text;
+ }
+ }
+ return "";
+}
+
+export function getAllPosts(): Post[] {
+ return fs
+ .readdirSync(POSTS_DIR)
+ .filter((f) => /\.(md|mdx)$/.test(f))
+ .map((file) => {
+ const raw = fs.readFileSync(path.join(POSTS_DIR, file), "utf8");
+ const { data, body } = parseFrontmatter(raw);
+ const slug =
+ typeof data.slug === "string" && data.slug ? data.slug : file.replace(/\.(md|mdx)$/, "");
+ return {
+ slug,
+ title: typeof data.title === "string" ? data.title : slug,
+ tags: Array.isArray(data.tags) ? data.tags : [],
+ image: typeof data.image === "string" ? data.image : undefined,
+ pubDate: typeof data.pubDate === "string" ? data.pubDate : "",
+ readTime: typeof data.readTime === "string" ? data.readTime : undefined,
+ excerpt: deriveExcerpt(body),
+ body,
+ };
+ })
+ .sort((a, b) => b.pubDate.localeCompare(a.pubDate));
+}
+
+export function getPost(slug: string): Post | undefined {
+ return getAllPosts().find((p) => p.slug === slug);
+}
+
+export function formatPostDate(pubDate: string): string {
+ const date = new Date(`${pubDate}T00:00:00Z`);
+ if (Number.isNaN(date.getTime())) return pubDate;
+ return date.toLocaleDateString("en-US", {
+ year: "numeric",
+ month: "long",
+ day: "numeric",
+ timeZone: "UTC",
+ });
+}
diff --git a/web/apps/web/package.json b/web/apps/web/package.json
index f9af5467e..9a77d64a3 100644
--- a/web/apps/web/package.json
+++ b/web/apps/web/package.json
@@ -5,6 +5,7 @@
"@nativelink/tokens": "workspace:*",
"@nativelink/ui": "workspace:*",
"geist": "^1.5.1",
+ "marked": "^16.4.2",
"motion": "^12.0.0",
"next": "^16",
"react": "^19.0.0",
diff --git a/web/bun.lock b/web/bun.lock
index 31f69219f..de3b65a22 100644
--- a/web/bun.lock
+++ b/web/bun.lock
@@ -43,6 +43,7 @@
"@nativelink/tokens": "workspace:*",
"@nativelink/ui": "workspace:*",
"geist": "^1.5.1",
+ "marked": "^16.4.2",
"motion": "^12.0.0",
"next": "^16",
"react": "^19.0.0",