June 12 - 16, 2025
JS Nation
Amsterdam & Online

JSNation 2025

The main JavaScript conference of the year

Full remote ticket included with Multipass.
Discover the future of the JavaScript development ecosystem and get connected to its stellar crowd! JSNation is the best place to learn about JavaScript – beside the main JS conf talks and panel discussion with high-profile specialists, be prepared for awesome MCs, in-depth workshops, a number of discussions & networking rooms, interactive entertainment, and engaging challenges for all participants.
Vite and the Future of JavaScript Tooling
Upcoming
Vite and the Future of JavaScript Tooling
At VoidZero, we have been hard at work on building the foundation for a unified toolchain for JavaScript. Over the past year and half, we have reworked everything inside Vite from the ground up, now running on a Rust-powered toolchain containing OXC and Rolldown. In this talk, we will discuss the why, the implications, and the future vision of all this work.
Resourceful Suspense
Upcoming
Resourceful Suspense
In modern apps we have millions of lines of code with data coming from a variety of data sources. To achieve swift user experience using a suspense-like pattern is non-negotiable. Only if there's something that could manage the complexities in suspense with prefetching, waterfalls, data dependencies, etc. How can we make suspense more resourceful?In this talk we'll see how templating and signals make the suspense pattern a breeze in Angular. Suspend your disbelief! There's a simpler async state with resources.
Motion Control With Multimodal LLMs
Upcoming
Motion Control With Multimodal LLMs
What if you could use multimodal LLMs to interact with websites or IoT devices using motion control?As advancements in multimodal AI offer new opportunities to push the boundaries of what can be done with this technology, I started wondering how it could be leveraged from the perspective of human-computer interaction.In this talk, I will take you through my research experimenting with building motion-controlled prototypes using LLMs in JavaScript.
The State of Node.js 2025
Upcoming
The State of Node.js 2025
Node.js continues to thrive despite claims of its decline. We'll debunk myths, highlight recent enhancements, and demonstrate its robust performance in today's tech landscape. The talk will cover Node.js's role in server-side programming and cloud-native applications, community contributions, integration of modern JavaScript features, and influence of emerging technologies. We'll conclude by projecting Node.js's bright future and growth areas in the evolving tech world.
The State of the Web
Upcoming
The State of the Web
A behind-the-scenes look at running the "State of" series of developer surveys (State of JS, CSS, etc.) as well as lessons learned and upcoming trends.
Transformers.js: State-of-the-Art Machine Learning for the Web
Upcoming
Transformers.js: State-of-the-Art Machine Learning for the Web
Learn about Transformers.js, an innovative JavaScript library for running state-of-the-art machine learning models 100% locally in your browser. With support for nearly 2 000 pretrained models, spanning a wide range of modalities and tasks, Transformers.js empowers developers to seamlessly integrate advanced ML capabilities into their web applications. We'll also explore how we leverage emerging web technologies like WebGPU and WebNN to create interactive, privacy-preserving, and scalable web experiences.
Building Web Extensions With Your Favourite Framework
Upcoming
Building Web Extensions With Your Favourite Framework
Do you want to automate daily manual tasks or explore extending browser functionality? This talk has you covered; we’ll break down how to build Web Extensions from scratch – covering architecture, state management, Manifest V3, best practices and tools to bring your ideas to life! 🚀
AI Right in the Browser With Chrome’s Built-in AI APIs
Upcoming
AI Right in the Browser With Chrome’s Built-in AI APIs
In this talk, Thomas Steiner from Google Chrome's AI team dives into the various built-in AI APIs that the team is currently exploring. First, there's the exploratory Prompt API that allows for free-form interactions with the Gemini Nano model. Second, there are the different task APIs that are fine-tuned to work well for a particular task like translations, language detection, summarization, and writing or rewriting. After introducing the APIs, the final part of the talk focuses on demos, applications, and use cases unlocked through these APIs.
The Built-in Browser-Based Babelfish
Upcoming
The Built-in Browser-Based Babelfish
AI progress is running away on the server-side, where the GPUs live, but the web platform is never that far behind. In this talk we're going to explore the incredible applications you can build in the browser today and in the near future.You'll see how to build an offline-capable, speech to speech language translation app, a babelfish, using nothing but the web platform. Through this app we'll explore the different ways we can run AI models in the browser today and what may be built into the browser in the future. From low-level standards to high-level experiments, you'll learn how to work with AI on the web.
Building Full Stack Apps With Cursor Composer
Upcoming
Building Full Stack Apps With Cursor Composer
Workshop
Mike Mikula
Mike Mikula
In this workshop I’ll cover a repeatable process on how to spin up full stack apps in Cursor.  Expect to understand techniques such as using GPT to create product requirements, database schemas, roadmaps and using those in notes to generate checklists to guide app development.  We will dive further in on how to fix hallucinations/ errors that occur, useful prompts to make your app look and feel modern, approaches to get every layer wired up and more!  By the end expect to be able to run your own AI generated full stack app on your machine!
Register
Supercharge Your Debugging With the New Features in Chrome Devtools
Upcoming
Supercharge Your Debugging With the New Features in Chrome Devtools
Barry Pollard
Ewa Gasperowicz
2 authors
Chrome DevTools just got a turbo boost! The Chrome DevTools team has been releasing new features at a furious rate over the past year, including  a complete Performance Panel overhaul with real-time Live Metrics and AI-powered Insights that'll expose bottlenecks you never knew existed. Forget tedious documentation searches and forum hunts; now, AI assists you directly within the Elements, Performance, Network and Sources panels, keeping you in the flow. Use the new alignment and collaboration tools to easily share your observations and debugging wizardry with your team and stakeholders, We'll unleash the full potential of these game-changing features, revealing hidden gems and shortcuts that'll transform your debugging workflow from a slog to a supercharged sprint. Get ready to code faster, debug smarter, and build experiences that fly.
Modern React Architecture
Jun 18, 14:00
Modern React Architecture
Workshop
Brad Westfall
Brad Westfall
In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework (aka Remix) along with React's new "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.
Register
Let's Create a GitHub Copilot Extension!
Upcoming
Let's Create a GitHub Copilot Extension!
Workshop
Nick Taylor
Nick Taylor
Get hands-on in this workshop where we'll create a GitHub Copilot Extension from scratch.We'll use the Copilot Extensions SDK, https://github.com/copilot-extensions/preview-sdk.js, and Hono.js, covering best practices like payload validation and progress notifications and error handling.We'll also go through how to set up a dev environment for debugging, including port forwarding to expose your extension during development as well as the Node.js debugger.By the end, we'll have a working Copilot extension that the audience can try out live.
Register
Testing the Waters With Deno
Upcoming
Testing the Waters With Deno
Let’s dive into the world of testing with Deno’s built-in test runner! Come on in, the water’s lovely!We’ll kick things off by exploring the principles of effective testing, perfect for beginners dipping their toes in. Then, we’ll introduce Deno’s out-of-the-box test runner.With the Deno.test API, you’ll be jetting in no time. We’ll cover how to write assertions and see firsthand how they help ensure your code behaves as expected.To wrap things up, we’ll explore writing tests that will be familiar to those experienced with Jest and Vitest, using Deno and its standard library. You’ll gain practical knowledge on how simple Deno makes setting up your testing environment, structuring your test cases, and optimizing your testing workflow.Whether you’re a seasoned developer or new to Deno, this talk will provide the tools and knowledge you need to confidently navigate the waters of testing in your Deno projects and make a splash with your testing skills!
Configurational Dependencies in pnpm
Upcoming
Configurational Dependencies in pnpm
pnpm v10 added support for a new type of dependency called "Configurational dependencies". These dependencies make it possible to develop pnpm plugins and share your configurations between projects.
Contributing to Web Standards
Upcoming
Contributing to Web Standards
Discover how you can shape the future of the web by contributing to web standards! In this talk, we’ll explore the process of creating and evolving web technologies, the role of standards organizations, and how developers of all levels can get involved. Learn practical steps to contribute your ideas, collaborate with global communities, and ensure the web remains open, accessible, and innovative for everyone.
a11y Testing Is Broken: How Lighthouse and Axe Fail in Real Projects
Upcoming
a11y Testing Is Broken: How Lighthouse and Axe Fail in Real Projects
The European Accessibility Act (EAA) is coming, and companies will rush to certify their websites as accessible in the easiest way possible. But high Lighthouse and Axe scores don't mean real accessibility. Many will rely on these tools to "prove" compliance, despite their critical blind spots – broken focus, misleading ARIA, and inaccessible dynamic content. Even more confusing, Lighthouse and Axe are built on the same foundation, yet they can produce different results. So let's break down these flaws and explore better ways to ensure true accessibility. 
Run TypeScript Natively in Node.js
Upcoming
Run TypeScript Natively in Node.js
Imagine the convenience of executing TypeScript files directly with Node.js using `node file.ts`. Just a few years ago, this concept seemed like a distant dream. Today, it stands as an exciting experimental feature. This talk narrates the journey of transforming this dream into a reality.
Hot Module Replacement is Easy
Upcoming
Hot Module Replacement is Easy
Learn how Vite's Hot Module Replacement (HMR) works under the hood and all the key concepts that power it.
Demystifying IPFS: A Web Developer's Guide to Content Distribution
Upcoming
Demystifying IPFS: A Web Developer's Guide to Content Distribution
IPFS is a peer-to-peer network distributing for content addressed data and can be thought of as a distributed CDN. Yet, given its evolutionary trajectory IPFS is often misunderstood. In this talk, you’ll learn about current state of IPFS with a focus on integration with the web platform using HTTP(S), how it enables local-first distribution of web apps, and real applications for you as a web developer.
The 2025 State of JavaScript Testing
Upcoming
The 2025 State of JavaScript Testing
Have we been stuck in the same testing pain loops for years? Even though it might seem like it, we haven't!Even if AI is now writing our tests, many JavaScript developers have faced numerous challenges, from the unclarity of test classifications to the struggle of mocking, long-running integration tests, and shifting everything to E2E tests.Let's recap everything that has happened in the past years and look into the present to explore what 2025 will bring for testing in the JavaScript world around test runners, testing libraries, mocking, production practices, and AI-based tools.
Surprise! Svelte Secretly Sending Signals
Upcoming
Surprise! Svelte Secretly Sending Signals
Svelte 5 introduced runes which use signals under the hood. While signals are very cool and unlock a ton of composability possibilities they have their own gotchas... let's explore them while creating a reactive signal based system from scratch to really understand them from the base!
Speeding Up Your Node Sever With Rust
Upcoming
Speeding Up Your Node Sever With Rust
Node has served you well: you spun up a prototype and iterated quickly, keeping up with the evolving requirements of a successful product. Nonetheless, as time goes on, cracks are starting to show up: an endpoint is slower than it needs to be, a data processing job that took seconds now takes almost an hour, and your infrastructure bill is growing too fast compared to the size of your user base. Engineers are starting to whisper: is it time for a rewrite? Should we pause feature development to rebuild everything on more solid foundations? That's an option, but it's expensive.There's another path: rather than throwing away your entire Node codebase to start over, you analyze your application and isolate the performance-critical bits—the so-called "hot modules" where your application spends most of its time. You will rewrite those in Rust and package them as a Node native extension. This talks shows you how.
TypeScript Gymnastics: Why Are They So Powerful for You?
Upcoming
TypeScript Gymnastics: Why Are They So Powerful for You?
In TypeScript’s type system is more than just a tool for catching errors—it’s a way to solve complex problems with clean and reliable code. In this talk, we’ll dive into advanced TypeScript techniques like mapped types, conditional types, and generics to handle even the trickiest type challenges.You’ll see how these techniques can help you extract, transform, and validate data types while keeping your code simple and maintainable. These "TypeScript gymnastics" aren’t just for show—they’re practical skills that make your systems stronger and easier to work with.Come learn how to take full advantage of TypeScript’s flexibility and power to build solutions that are as smart as they are safe.
What Is an AnimationFrame and What Can It Tell You?
Upcoming
What Is an AnimationFrame and What Can It Tell You?
Modern web applications need to be responsive and smooth, providing users with immediate feedback for their interactions. To understand how well our applications perform, we need to understand how browsers process and render content. This is why we now have AnimationFrames, a new representation of unit of work that powers INP and LoAF APIs!
Bundlers: A Deep Dive into Modern JavaScript Build Tools
Upcoming
Bundlers: A Deep Dive into Modern JavaScript Build Tools
Modern JavaScript bundlers are architectural marvels that transform complex codebases into optimized production assets. This technical deep dive deconstructs how bundlers like Vite, webpack, or Rollup work under the hood, revealing the engineering that powers our build tools.

We will journey through the bundling pipeline, starting from the understanding of the AST, parsing and static analysis for dependency resolution, some core optimizations like tree-shaking and code spitting, closing with some advanced concepts like HMR.
10 Years of Best of JS
Upcoming
10 Years of Best of JS
The story behind the project, its mission to curate the best of the JavaScript ecosystem, and how it has adapted to the ever-changing landscape. We’ll also explore the key trends, tools, and technologies that have shaped JavaScript over the past decade.
Build Your Own Reactivity: A Deep Dive Into Signals
Upcoming
Build Your Own Reactivity: A Deep Dive Into Signals
Signals have been revolutionizing state management lately, offering a more intuitive and performant approach than traditional methods. But what kind of magic is there under the hood? You change a value, and all places that use that value update and recalculate themselves automagically… 🤔In this talk we will look behind the curtain and explore the inner workings of Signals, by building our own implementation from scratch (Disclaimer: use for learning purposes only 😉).Signals have become almost a de facto building block in JavaScript frameworks lately, with some notable exceptions (looking at you React 👀), so it really pays off to have a deeper understanding about how they operate, how to debug them effectively and how to avoid common pitfalls. Plus, who doesn't like a bit of live coding? ✨
Temporal: The Curious Incident of the Wrong Nighttime
Upcoming
Temporal: The Curious Incident of the Wrong Nighttime
This is the story of how I almost spent a night on the street — because of JavaScript's Date object! We'll dive in and try to understand why that happened, and how to prevent it. Luckily coming soon to a browser near you is Temporal, the JavaScript built-in API that makes this kind of mess-up a thing of the past.
Web Almanac 2024: Is the Web Sustainable?
Upcoming
Web Almanac 2024: Is the Web Sustainable?
Dive into the environmental impact of the web through key insights from the HTTP Archive Almanac 2024. Discover shocking statistics about web sustainability, from massive page weights to unused code, and learn practical, immediate solutions to reduce your website's carbon footprint. This talk combines hard data with actionable strategies to make the web greener
JSR: Building an Open Registry for the JavaScript Community
Upcoming
JSR: Building an Open Registry for the JavaScript Community
JSR is a community-driven, modern JavaScript registry with a mission to improve the ecosystem through transparency, openness, and innovation. Hear about recent developments, including the establishment of its governance board, ongoing projects and initiatives, and how these efforts directly benefit JavaScript developers. Discover how the community can engage directly, contribute to JSR’s direction, and get insights into the project’s goals and upcoming milestones. 
When JavaScript Meets OpenTelemetry: It's Observability O'Clock
Upcoming
When JavaScript Meets OpenTelemetry: It's Observability O'Clock
Ever used an app that crashed and thought, "Why can’t this just work?" For users, it’s frustrating. For businesses, it’s expensive. As JavaScript developers, we’re stuck in the middle - juggling frontend tweaks, backend performance, and monitoring tools to figure out what went wrong. That’s where observability comes in because understanding your code is like going to the gym. No shortcuts, no pills. You gotta put in the work to put on the muscle.  It’s not just some SRE buzzword anymore but a must-have for developers. Observability helps you spot issues, understand system behavior, and fix problems faster. And with OpenTelemetry, you get an open-source framework to manage logs, traces, and metrics without vendor lock-in. In this session, you’ll learn, all things observability, optimize both frontend and backend, and integrate OpenTelemetry to gain insights into your system. Moreover, you'll also learn how to practically integrate OpenTelemetry into your JavaScript apps, to create spans, track activities, name them effectively. The result? Fewer headaches, better performance, and apps that not just works but you completely understands.
JavaScript Isn’t Slow – It’s Just Scheduled Wrong
Upcoming
JavaScript Isn’t Slow – It’s Just Scheduled Wrong
In this session, we’ll explore why JavaScript’s single-threaded model causes UI lag, why setTimeout() and requestIdleCallback() fail at task prioritization, and how scheduler.postTask() finally gives developers fine-grained control over execution.Through real-world examples, performance analysis, and a live demo, we’ll show how prioritized scheduling can eliminate UI freezes, improve responsiveness, and make JavaScript execution truly user-centric. If you care about JavaScript performance, this is the talk you don’t want to miss! 🚀
Auth: Build vs Open Source vs Buy
Upcoming
Auth: Build vs Open Source vs Buy
Starting a new application? Have an existing application that is growing? Choosing the right authentication solution can make or break your product. Should you buy a solution, build your own from scratch, or try an open-source project? The pros and cons of each approach will be discussed. Whether you are a startup founder, product manager or developer, this session will equip you with the insights needed to make an informed choice that aligns with your business goals and technical requirements. 
Real-Time Robot Control From the Browser With WebRTC
Upcoming
Real-Time Robot Control From the Browser With WebRTC
Explore a world of hardware the likes of which you've never seen before! This presentation will contain live demos using both local robots and those in production from across the country. While the technology being used is advanced, the approach is accessible to anyone whose used JavaScript before.The talk covers the architecture of WebRTC as a stack of technologies for enabling peer-to-peer communication, as well as how it can be leveraged for interacting with embedded hardware and robotics from the browser, all using JavaScript APIs. My goal is to make programming devices more accessible to web developers and demonstrate a practical solution for taking hobby projects from your desk to production. 
Divide and Conquer? - Exploring the 'JS0' and 'JSSugar' Proposal for JavaScript Evolution
Upcoming
Divide and Conquer? - Exploring the 'JS0' and 'JSSugar' Proposal for JavaScript Evolution
In October 2024, a language evolution proposal was submitted to the TC39 Javascript Committee meeting. In it, a new vision for JS as a whole is shown, one in which the language is seemingly split in two - a core ""JS0"" and an extended ""JSSugar"". What is this about, why did it come up at this point and what does it mean for us as JavaScript developers?In this short talk, we'll go over the proposal, exploring what it tries to accomplish, how and its potential pros and cons from a neutral, community-first perspective.
Sustainable Web Development in Startups: Applying Green Coding Principles for a Greener Future
Upcoming
Sustainable Web Development in Startups: Applying Green Coding Principles for a Greener Future
As IT professionals, we play a critical role in energy consumption and emissions, and it's our responsibility to address this impact. By adopting greener practices in web development, we can contribute to achieving climate goals while still driving innovation and growth. I'll share insights of how we integrated principles of green web development in the redesign of our website and explain their impacts.
Third-Party Scripts: Surviving the Wild West of the Web
Upcoming
Third-Party Scripts: Surviving the Wild West of the Web
As third-party script developers, we constantly work in environments we don't fully control. We must handle unexpected issues introduced by different browsers, quirky customizations made by the primary developer team, and security restrictions we can't easily bypass. In this introductory-level session, I will share first-hand experiences and practical guidance derived from building and deploying third-party scripts to improve your team's confidence and workflow efficiency.
Live Coding: Eliminating Redundant Runtime Checks with Config as Code&Type in TypeScript
Upcoming
Live Coding: Eliminating Redundant Runtime Checks with Config as Code&Type in TypeScript
Workshop
Jannik Sommerfeld
Jannik Sommerfeld
In this workshop, we’ll explore how to manage application configurations directly in your Git repository and integrate them into the TypeScript type system. The goal is to make your code aware of the actual configuration at compile-time, reducing the need for runtime validation and unit tests.You'll discover:How to create lossless types for static dataTechniques to eliminate unnecessary code paths and reduce runtime validationHow to leverage utility types to extract specific information from configurationsKey TypeScript operators and how to handle common pitfalls when working with generic typesBest practices for improving type safety and developer experienceBy the end of this workshop, you'll have a solid understanding of how to implement Config as Code in your TypeScript projects, enhancing maintainability, type safety, and autocomplete support. This workshop is ideal for TypeScript developers looking to optimize their code and streamline configuration management.
Register
Prompt Engineering Toolkit
Upcoming
Prompt Engineering Toolkit
A centralized prompt engineering toolkit to help developers build better applications powered by LLMs. This toolkit provides tools and best practices for crafting effective prompts, managing prompt versions, and evaluating the performance of LLM-based features. Furthermore, there’s a need for version control, collaboration, and robust safety measures (hallucination checks, standardized evaluation framework, and a safety policy) to ensure responsible AI usage. 
How We Rebuild the Creative Playground That Flash Took to the Grave
Upcoming
How We Rebuild the Creative Playground That Flash Took to the Grave
Remember when Flash ruled the web, and you could build mind-bending interactive experiences without battling WebGL shaders, fighting scene graph hierarchies, or summoning dark forces to debug matrix transformations? Good times. 

Now, 3D web development is back—with WebXR, Three.js, and WebGPU leading the charge—but where’s the tooling to match?
In this talk, we’ll explore how modern devs can reclaim the golden age of interactive 3D without losing their sanity, diving into the pain points of today’s workflows and the solutions that are making immersive development fun again.
The Future of Numerical Computing in JavaScript
Upcoming
The Future of Numerical Computing in JavaScript
JavaScript is evolving beyond web development and into the realm of high-performance numerical computing. In this talk, we’ll explore the current landscape of scientific computing in JavaScript, compare its performance with Python and C, and discuss what’s missing. Through live demos – including AI, real-time data processing, and mathematical computing – we’ll see how libraries like stdlib and a few others are shaping the future.
How to 10x Your Development Speed with Cline
Upcoming
How to 10x Your Development Speed with Cline
Workshop
Nik Pash
Nik Pash
The way we write code is fundamentally changing. Instead of getting stuck in nested loops and implementation details, imagine focusing purely on architecture and creative problem-solving while your AI pair programmer handles the execution. In this hands-on workshop, I'll show you how to leverage Cline (an autonomous coding agent that recently hit 1M VS Code downloads) to dramatically accelerate your development workflow through a practice we call "vibe coding" - where humans focus on high-level thinking and AI handles the implementation.You'll discover:The fundamental principles of "vibe coding" and how it differs from traditional developmentHow to architect solutions at a high level and have AI implement them accuratelyLive demo: Building a production-grade caching system in Go that saved us $500/weekTechniques for using AI to understand complex codebases in minutes instead of hoursBest practices for prompting AI agents to get exactly the code you wantCommon pitfalls to avoid when working with AI coding assistantsStrategies for using AI to accelerate learning and reduce dependency on senior engineersHow to effectively combine human creativity with AI implementation capabilitiesWhether you're a junior developer looking to accelerate your learning or a senior engineer wanting to optimize your workflow, you'll leave this workshop with practical experience in AI-assisted development that you can immediately apply to your projects. Through live coding demos and hands-on exercises, you'll learn how to leverage Cline to write better code faster while focusing on what matters - solving real problems.
Register
Sharing Is Caring – Boosting Micro-frontends Performance With Dependency Sharing
Upcoming
Sharing Is Caring – Boosting Micro-frontends Performance With Dependency Sharing
Join me as we take a look into the dark side of micro-frontends - dependency duplication. Ever wondered what happens to your overall bundle size when you break a huge SPA into dozens of micro-frontends? In this session we’ll share our journey with sharing dependencies between micro-frontends in monday.com to reduce overall bundle size on the page and increase performance.