software-mansion/popcorn

This system is a development toolchain and runtime environment that enables Elixir and Erlang code to execute directly in the browser via WebAssembly. It provides the core Popcorn infrastructure for compiling, building, and serving WebAssembly modules, alongside a LocalLiveView engine that allows Phoenix LiveView components to run client-side. The repository also includes a suite of interactive examples and a documentation generator (Popdoc) that demonstrate these capabilities.

A new Dockerfile and .dockerignore are introduced to build the local-lv-burrito application. The build process leverages a Popcorn base image, installs dependencies via Mix, and compiles the application for the 'wasm' target using 'mix popcorn.cook', followed by standard Elixir/Phoenix build steps like esbuild and tailwind compilation.

docker/burrito · high confidence

The Elixir language tour now includes a new backend implementation that enables interactive code evaluation. This change introduces three new Elixir modules: ElixirTour (a GenServer managing editor state and bindings), ElixirTour.Evaluator (a GenServer for executing Elixir code strings), and ElixirTour.Application (the OTP application supervisor). These components work together to allow the language tour to execute and display the results of Elixir code snippets, supporting the interactive learning experience.

_language-tour/elixir\tour · high confidence

The \examples/game-of-life\ directory now contains a complete, runnable example of Conway's Game of Life. This includes the Elixir backend (GenServers for cells, grid, and simulation logic), a JavaScript frontend that initializes the Popcorn runtime, and Playwright-based end-to-end tests. The example is designed to run on the OTP/BEAM WebAssembly runtime, with a specific toolchain configuration (Elixir 1.19.5 / OTP 28) to match the target environment.

examples/game-of-life, examples/hello-popcorn · high confidence

The main layout template now includes Google Tag Manager (GTM) scripts and a noscript fallback, activated only in production environments. This enables tracking of user interactions and page views via GTM ID GTM-PB7X3QRL.

landing-page/src/layouts · high confidence

The iex-wasm example now provides a complete, runnable demonstration of Elixir and Erlang running in the browser via WebAssembly. This includes the necessary build scripts, HTML templates for both Elixir and Erlang terminals, and the JavaScript/TypeScript glue code to initialize the Ghostty terminal and communicate with the Wasm runtime. The example also includes Elixir configuration for the Popcorn Wasm runtime and a basic test setup.

examples/iex-wasm · high confidence

The local-lv-kanban example now includes a complete frontend setup for the Kanban board demo. This adds Tailwind CSS and the daisyUI component library to the example's CSS, along with a TypeScript configuration for the project. The example also includes a \.formatter.exs\ file to configure Elixir code formatting for the new directory structure, and a \.gitignore\ file to exclude build artifacts and temporary files.

examples/local-lv-kanban · high confidence

A new example application demonstrating Local LiveView forms is added to the examples/local-lv-forms/local directory. This includes the core components, form logic, and user model, along with a test suite that validates the form's mount, validation, and save behaviors on a native AtomVM runtime.

examples/local-lv-forms/local · high confidence

A new example project has been added to demonstrate the differences between Popcorn's Local Live View and Phoenix Live View. The project provides a side-by-side comparison, rendering a Phoenix LiveView on the left and a LocalLiveView on the right, allowing users to observe behavioral differences such as latency simulation. The example includes all necessary Phoenix scaffolding, including controllers, layouts, components, and routing, alongside the specific LocalLiveView implementation.

examples/local-lv-compare · high confidence

Added new Astro pages for the landing page that showcase LocalLiveView capabilities. This includes a interactive Elixir REPL (eval), a Game of Life simulation, a local forms demo, and a thermostat control demo. Each page initializes the Popcorn runtime via JavaScript to run Elixir code locally in the browser, demonstrating the framework's ability to handle complex, interactive UIs without a server.

landing-page/src/pages · high confidence

Added configuration files for the LocalLiveView example application, including \config.exs\, \dev.exs\, \prod.exs\, \runtime.exs\, and \test.exs\. These files configure the Phoenix endpoint, LiveView settings, asset watchers (esbuild, tailwind), logging, and environment-specific behaviors such as hot-reloading in development and SSL enforcement in production.

examples/local-lv-compare/config · high confidence

A new LocalLiveView example has been added to the repository, featuring a modal component that handles open/close events. This example includes a dedicated test suite that validates the component's behavior on a native AtomVM runtime, ensuring the offline implementation matches the expected HTML output for both open and closed states.

examples/local-lv-compare/local · high confidence

Introduces a new example application demonstrating how to build forms using LocalLiveView. The example features a form that handles onchange and onsubmit events locally, with validation driven by Ecto changesets. It illustrates the persistent nature of a local-first approach by synchronizing state between the local LiveView and the server-side Phoenix LiveView, allowing users to see data persist locally even if the server is restarted.

examples/local-lv-forms · high confidence

The local directory now contains a complete LocalLiveView example featuring a thermostat and a clock LiveView, along with configuration for Phoenix and tree-shaking. A new test suite validates the thermostat's behavior on the native AtomVM runtime, confirming that the view correctly renders initial state and handles temperature increment/decrement events.

examples/local-lv-thermostat/local · high confidence

The local-lv-thermostat example now features a home page that renders two separate LiveViews (ThermostatLive and ClockLive) using the new .local\_live\_view component, demonstrating how to embed multiple independent LiveViews on a single page. The example includes a complete Phoenix application structure with Tailwind CSS and daisyUI styling, a theme toggle for dark/light modes, and standard Phoenix components like flash messages and error templates.

examples/local-lv-thermostat · high confidence

A new Pong game demo has been added to the \examples/local-lv-pong\ directory, showcasing a complete Phoenix application built with Local LiveView. The example includes a Tailwind CSS setup with daisyUI themes, a TypeScript configuration for the frontend, and a \.formatter.exs\ file to enforce Phoenix coding standards. This provides a reference implementation for building interactive, game-like interfaces using LiveView's real-time capabilities.

examples/local-lv-pong · high confidence

The examples/hello-react directory now contains a complete React + Vite application alongside an Elixir (OTP) application. The React side is configured with TypeScript, ESLint, and the React Compiler, while the Elixir side includes standard OTP project files (config, tests, formatter). This change introduces a new example demonstrating how to integrate a React frontend with an Elixir backend using the Popcorn library.

examples/hello-react · high confidence

A new interactive example, eval-in-wasm, allows users to type and run Elixir or Erlang code directly in the browser via WebAssembly. The example provides two HTML pages (one for Elixir, one for Erlang) with text areas for code input, an evaluate button, and a logs section. The backend is a GenServer (EvalInWasm) that uses the Popcorn library to compile and evaluate the code. Browser tests verify the functionality using Playwright.

examples/eval-in-wasm · high confidence

The example application now includes the daisyUI CSS framework, the topbar loading indicator, and Heroicons for the frontend, alongside English error message translations, enabling a fully styled and localized UI in the local thermostat example.

examples/local-lv-thermostat/assets/vendor, examples/local-lv-thermostat/priv · high confidence

The landing page now includes a new .gitignore file to exclude the wasm/ directory, a favicon.svg icon for the site, and a cookie-script.js file that currently serves as a stub logging a trace message. These additions support the landing page's visual identity and handle cookie consent logic, though the cookie script is not yet fully implemented.

landing-page/public · medium confidence

The local-lv-burrito example application is introduced, providing a side-by-side comparison of standard Phoenix LiveView and Local LiveView. The demo features a burrito ordering form that runs in both environments simultaneously, allowing users to observe differences in responsiveness and offline capabilities. The implementation includes a split-screen layout with synchronized scrolling, connection status indicators, and a sync panel that displays the state received from the Local LiveView instance.

examples/local-lv-burrito · high confidence

The Hello React example now includes a standard OTP application structure, introducing an ExApp GenServer and its corresponding Application module to manage the process lifecycle and supervision tree.

_examples/hello-react/ex\app · medium confidence

The local-lv-compare example now includes pre-built vendor assets for daisyUI (theme and plugin logic), Heroicons (Tailwind CSS plugin for SVG icons), and topbar.js (a lightweight progress bar library). Additionally, English localization files for error messages have been added to support internationalization within this example.

(repo-wide) · high confidence

Added the main JavaScript entry point for the local-lv-forms example, establishing the Phoenix LiveSocket connection and initializing the Local Live View engine with a specific WASM bundle path. This file also configures the topbar loading indicator and enables Phoenix live-reload development features such as server log streaming and editor integration.

examples/local-lv-forms/assets/js · high confidence

The example application's JavaScript entry point (app.js) has been created to configure the Phoenix LiveView integration. This includes setting up the Phoenix socket, importing the local\_live\_view engine to handle local rendering, and configuring the topbar for page loading states. The setup also includes hooks for Phoenix LiveView and enables development features like server log streaming and hot-reloading assistance.

examples/local-lv-compare/assets/js · high confidence

The thermostat example now initializes a Local Live View (LLV) engine alongside the standard Phoenix LiveView socket. This change enables the execution of WebAssembly-based components (specifically the thermostat's WASM bundle) within the browser, allowing the example to demonstrate local, client-side rendering capabilities in addition to standard server-driven LiveView interactions.

examples/local-lv-thermostat/assets/js · high confidence

The Elixir/OTP portion of the Popcorn project has been reorganized and expanded. A new \.formatter.exs\ and \.gitignore\ are added to standardize code formatting and ignore build artifacts. The \Popcorn.Application\ module now registers a supervisor and, if running in a WebAssembly environment, installs \Popcorn.Fetch\ as the default adapter for the \Req\ HTTP client, enabling HTTP requests to run through the browser's \fetch()\ API. A new \Popcorn.Fetch\ module implements this adapter, handling chunked responses and timeouts. Additionally, \Popcorn.Proxy\ is introduced to allow JavaScript to call and cast to GenServers running in the VM, while \Popcorn.Wasm\ provides utilities for running JavaScript code and sending messages between Elixir and the browser. Finally, a \Popcorn.Server\ Mix task is added to start a static file server with the necessary headers for WebAssembly.

popcorn/elixir · high confidence

LocalLiveView allows developers to run Phoenix LiveView components entirely in the browser using the Popcorn WASM runtime. This feature introduces a new architecture where LiveView processes run locally, communicating with the host Phoenix application via a custom transport layer. The implementation includes a TypeScript-based frontend engine that manages view lifecycle, event handling (including mouse, drag-and-drop, and navigation), and a corresponding Elixir backend with a dispatcher and server processes. It also provides Mix tasks (\llv.install\, \llv.build\) to integrate the runtime, copy static assets, and generate sample projects, enabling a seamless developer experience for building interactive, client-side views.

local-live-view · high confidence

The Popcorn project has been restructured into version 2, introducing a comprehensive suite of new capabilities for building and running Elixir applications in the browser. Developers can now use new Mix tasks to build the AtomVM runtime (\popcorn.build\_runtime\), compile Elixir code into \.avm\ bundles (\popcorn.cook\), generate JavaScript assets (\popcorn.gen.js\), and start a static file server with required WebAssembly headers (\popcorn.server\). The core \Popcorn.cook/1\ API now supports an experimental \treeshake\ option to reduce bundle size by removing unused modules and functions. Additionally, the update includes a new \Popcorn.Wasm\ module for JavaScript interop, an \ArtifactsCache\ for build optimization, and a \BuildLogFormatter\ to improve build output readability.

(repo-wide) · high confidence

Added the initial version of Popdoc, a new tool for generating Elixir documentation. This includes a Wasm-based GenServer implementation (PopdocWasm) that handles parsing and evaluating Elixir code snippets, and a corresponding E2E fixture (Example module) to support end-to-end testing of the documentation generation workflow.

popdoc/e2e/fixture, popdoc/wasm · high confidence

Popdoc is a new ExDoc extension that enables interactive execution of Elixir code blocks in generated documentation. It adds a 'Run' button to fenced code blocks marked with the \elixir-popcorn\ class, allowing users to execute code directly in the browser. The feature includes a JavaScript frontend for handling execution, a Mix task to build the necessary assets, and a development server that serves the documentation with the required Cross-Origin headers for WebAssembly. End-to-end tests verify the interactive behavior.

popdoc · high confidence

The language-tour area now contains a complete, interactive tutorial application for learning Elixir. It features a React frontend with a CodeMirror-based editor that executes Elixir code in the browser via WebAssembly (Popcorn). The app includes dynamic routing for MDX-based lessons, a state management store for code editors, and UI components for code execution, status badges, and toast notifications. Configuration files (\.env.example\, \.gitignore\, \.prettierrc\, \eslint.config.js\) and a Playwright E2E test setup are also included.

language-tour · high confidence

The repository now includes a suite of new shell scripts in the \scripts/\ directory to streamline building and testing. \build-atomvm.sh\ and \build-beam.sh\ automate compiling the AtomVM and Erlang/OTP sources for WebAssembly and Unix targets, handling source cloning, patching, and CMake/autotools configuration. \build-openssl.sh\ manages the OpenSSL build for the WASM target. \patch-beam.sh\ applies and regenerates OTP patches, while \stdlib.sh\ generates precompiled stdlib tarballs. A new \dev.sh\ script launches development servers for examples and projects with file watching, and \test.sh\ provides a unified entry point to run Elixir, JavaScript, and Popdoc tests across different targets. These scripts replace the previous ad-hoc build processes, offering consistent interfaces for developers to build, test, and run the Popcorn 2 ecosystem.

scripts · high confidence

The landing-page area is initialized with a complete project scaffold, including an Astro configuration (astro.config.mjs) that integrates React, Tailwind CSS, and custom Vite plugins for building and bundling WebAssembly assets. The setup includes TypeScript configuration (tsconfig.json), Prettier formatting rules (.prettierrc), a .gitignore file, and documentation style guides (llm-documentation-rules.md, technical-documentation-rules.md) to standardize content creation.

landing-page · high confidence

The local-lv-checkout example is initialized with Phoenix LiveView scaffolding, including a \.formatter.exs\ for Elixir code formatting, a \.gitignore\ for build artifacts, and a \README.md\. It also introduces Tailwind CSS and daisyUI for styling, with \app.css\ configuring themes and custom variants, while \app.js\ sets up the Phoenix LiveSocket and the LocalLiveView engine. TypeScript support is added via \tsconfig.json\, and vendor assets like \daisyui-theme.js\ are included.

examples/local-lv-checkout · high confidence

The repository now includes dedicated Dockerfiles to build and serve the landing page, language tour, and release packages. The base image (base.Dockerfile) installs Node.js, pnpm, Erlang/OTP, Elixir, and Emscripten to compile the AtomVM WebAssembly runtime. The landing and langtour Dockerfiles use this base to build the respective frontend applications and serve them via Nginx, with the landing page including a configurable cookie consent script. The release Dockerfile builds the production assets and packages them into a tarball for distribution.

docker · high confidence

The landing page has been rebuilt with new Astro components including a header, footer, and sections for features, examples, and a live demo. A 3D model of a popcorn kernel is now rendered on the page using Three.js, with the model's position and scale animating based on scroll position. The live demo section now uses a terminal emulator (ghostty-web) to run Elixir code in the browser.

landing-page/src/components · high confidence

The \app.css\ files for the \local-lv-compare\ and \local-lv-forms\ example applications have been updated to include Tailwind CSS and daisyUI theme configurations. This introduces dark and light theme support, LiveView loading state variants, and example-specific component styles (such as \.modal\, \.show-modal-button\, \.centered-div\, and \.ghost-button\) to enhance the visual presentation of these demo applications.

examples/local-lv-compare/assets/css, examples/local-lv-forms/assets/css · high confidence

The landing page now includes a new TypeScript declaration file (env.d.ts) that defines types for global variables (Popcorn, terminal) and Vite environment variables (ImportMetaEnv). This improves type safety for the landing page's integration with external scripts and build-time environment configuration.

landing-page/src · high confidence

The examples/hexdocs directory now includes two new submodules for Elixir and Ex Doc, providing example implementations for these technologies.

examples/hexdocs · medium confidence

The Hello Popcorn example has been restructured to use the new OTP-based JavaScript integration, featuring a build script that bundles the application with esbuild and the Popcorn plugin. The example now includes an HTML entry point and a JavaScript module that initializes Popcorn with a manifest URL and handles stdout. Additionally, Playwright end-to-end tests have been added to verify the WASM output and console logs, ensuring the example functions correctly in a browser environment.

examples/hello-popcorn/assets · high confidence

The configuration files for the \local-lv-forms\ and \local-lv-thermostat\ example applications have been updated to support the new Local Live View architecture. This includes adding \local\_live\_view\ to the development watchers for hot-reloading, enabling \debug\_heex\_annotations\ and \enable\_expensive\_runtime\_checks\ in Phoenix Live View for both development and test environments, and configuring the \Bandit.PhoenixAdapter\ with appropriate endpoint and static asset settings. These changes ensure the examples correctly integrate with the \local\_live\_view\ dependency and provide the necessary runtime checks and debugging tools for developers.

examples/local-lv-forms/config, examples/local-lv-thermostat/config · high confidence

Add test suite for error handling and modal interactions; Added E2E test utilities for app startup and state management; Added demo\_app fixture with dead code and protocols for treeshake tests; Added end-to-end tests and build plugins for the JS/OTP bridge; Added test coverage for the local LiveView forms example; Added test suite for the local thermostat example; Added tests for Popcorn Elixir modules.

The repository now includes new example applications that demonstrate how to use Popcorn and LocalLiveView in different contexts. This includes Elixir/OTP examples (eval-in-wasm, game-of-life, hello-popcorn, iex-wasm, local-lv-burrito, local-lv-checkout, local-lv-compare) and a React-based example (hello-react). Each example is configured with its own \mix.exs\ and \package.json\ files, linking to the local \popcorn\ and \local-live-view\ packages, and includes the necessary build and development aliases to compile, build assets, and serve the applications.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 44 (-1.6)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 83 → 83 (-0.0)
• Architecture 92 → 93 (+0.3)
• Maturity 75 → 79 (+4.3)
• Readiness 29 → 30 (+0.8)
• Security 58 → 47 (-11.3)
• Accessibility 45 → 45 (-0.0)

• Change coupling: History.tsx ↔ Results.tsx (language-tour/src/components/execution/History.tsx)
• Change coupling: PopcornProvider.tsx ↔ vite.config.ts (language-tour/src/context/popcorn/PopcornProvider.tsx)
• Change coupling: beam.ts ↔ popcorn.ts (otp/js/src/beam.ts)
• Dimension evaluation failed
• Duplicated block (11 lines × 3) (examples/local-lv-burrito/lib/burrito_web/live/ordering_form_component.ex)
• Duplicated block (11 lines × 7) (examples/local-lv-burrito/lib/burrito_web/telemetry.ex)
• Duplicated block (15 lines × 7) (examples/local-lv-checkout/lib/local_lv_checkout_web/components/core_components.ex)
• Duplicated block (19 lines × 2) (examples/local-lv-burrito/local/lib/burrito_live.ex)
• Duplicated block (5 lines × 2) (popcorn/elixir/lib/popcorn/core_erlang_utils.ex)
• Duplicated block (6 lines × 7) (examples/local-lv-checkout/lib/local_lv_checkout_web/components/core_components.ex)
• Duplicated block (8 lines × 2) (examples/local-lv-burrito/lib/burrito_web/live/sync_table_live.ex)
• Duplicated block (8 lines × 2) (otp/utils/popcorn_server.ex)
• Further sole-owners (lower concentration)
• High: security finding (details withheld)
• Hotspot: otp/js/src/errors.ts (otp/js/src/errors.ts)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• The README is a Popdoc installation guide and does not mention how to run the Popcorn server locally or serve docs from a web server. (popdoc/README.md)

• Change coupling: Results.tsx ↔ PopcornProvider.tsx (language-tour/src/components/execution/Results.tsx)
• Critical CVE: [GHSA redacted] (landing-page/package-lock.json)
• Critical CVE: [GHSA redacted] (landing-page/package-lock.json)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Duplicated block (10 lines × 3) (examples/local-lv-burrito/lib/burrito_web/live/ordering_form_component.ex)
• Duplicated block (10 lines × 7) (examples/local-lv-burrito/lib/burrito_web/telemetry.ex)
• Duplicated block (13 lines × 7) (examples/local-lv-checkout/lib/local_lv_checkout_web/components/core_components.ex)
• Duplicated block (17 lines × 2) (examples/local-lv-burrito/local/lib/burrito_live.ex)
• Duplicated block (5 lines × 7) (examples/local-lv-checkout/lib/local_lv_checkout_web/components/core_components.ex)
• Duplicated block (7 lines × 2) (examples/local-lv-burrito/lib/burrito_web/live/sync_table_live.ex)
• Duplicated block (8 lines × 2) (popcorn/utils/popcorn_server.ex)
• Duplicated block (9 lines × 6) (examples/local-lv-burrito/lib/burrito_web/telemetry.ex)
• High CVE: [GHSA redacted] (landing-page/package-lock.json)
• High CVE: [GHSA redacted] (local-live-view/mix.lock)
• High CVE: [GHSA redacted] (landing-page/package-lock.json)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (local-live-view/mix.lock)
• High CVE: [GHSA redacted] (landing-page/package-lock.json)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 55 more

• 15 commits — 14 feature/other, 1 fixes

• popcorn/js — 4 commits
• otp/js — 3 commits
• .github/actions — 1 commit
• examples/game-of-life-otp — 1 commit
• local-live-view/lib — 1 commit
• otp/elixir — 1 commit
• otp/patches — 1 commit
• popcorn-2/elixir — 1 commit
• scripts/build-beam.sh — 1 commit
• scripts/stdlib.sh — 1 commit

• fix: scripts: fix tarball creation (#728)
• change: [LLV] Figure out how to assign IDs to LLVs (#702)
• change: ci: use release build for e2e (#729)
• change: otp: add a Req adapter backed by browser fetch (#722)
• change: otp: avoid nested BEAM compression (#714)
• change: otp: disable distribution start (#719)
• change: otp: honor MIX_ENV when packing apps (#727)
• change: otp: increase pool size (#715)
• change: otp: intercept spawning OS processes (#720)
• change: otp: migrate examples (#733)
• change: otp: move into popcorn/ (#724)
• change: otp: restore closure minification (#731)
• change: otp: wait for app boot (#732)
• change: popcorn: move to popcorn-2 (#723)
• change: scripts: remove closure minification (#730)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

software-mansion/popcorn was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.