{"slug": "deno-s-other-open-source-projects", "title": "Deno's Other Open Source Projects", "summary": "The article summarizes several open-source projects developed by the Deno team, all released under the MIT license. Key projects include **rusty_v8** (Rust bindings for the V8 JavaScript engine, now stable with over 3 million downloads), **deno_core** (which builds on rusty_v8 to map JavaScript Promises to Rust Futures for creating custom runtimes), and **rust-urlpattern** (a Rust implementation of the URLPattern web API). Other tools mentioned are **import_map**, **eszip**, **dnt**, **wasmbuild**, and **deno_task_shell**, each designed to solve specific development challenges.", "body_md": "Deno's Other Open Source Projects\nDeno’s codebase - and most of what we build around it - is open source under the permissive MIT license. Over the years, we’ve published dozens of supporting libraries and tools that solve common problems we’ve run into while building Deno. Here are a few we think others may find useful.\nrusty_v8\n: Rust bindings to the V8 JavaScript enginedeno_core\n: builds onrusty_v8\nto provide higher level functionality, like mapping JavaScriptPromises\nto RustFutures\nrust-urlpattern\n: implementsURLPattern\nweb API in Rustimport_map\n: implements the import map spec in Rusteszip\nandeszip_viewer\n: a binary file format for distributing an entire module graph of TypeScript filessui\n: a library for embedding data executable files in a cross platform waydnt\n: Deno to npm package build toolwasmbuild\n: Build tool to use Rust code in Deno and the browsermonch\n: lightweight parser, similar tonom\n, focused on stringsdeno_task_shell\n: cross-platform shell fordeno task\n.flaky_test\n: atttribute macro for running a flaky test multiple timesvnotify\n: monitor millions of S3 objects without external dependencies- What’s next\nRusty V8\nRusty V8 provides high-quality, zero-overhead Rust bindings to V8’s C++ API, and is the core of the Deno runtime. We made this library, which has undergone over 150 releases and downloaded more than 3 million times on crates.io, stable and production ready last year. You can use Rusty V8 to build custom JavaScript runtimes, run WebAssembly modules, use the V8 Fast API, and much more.\nHere’s an example of how you can embed JavaScript in a Rust program with\nrusty_v8\n:\nfn main() {\n// Initialize V8.\nlet platform = v8::new_default_platform(0, false).make_shared();\nv8::V8::initialize_platform(platform);\nv8::V8::initialize();\n// Create a new Isolate and make it the current one.\nlet isolate = &mut v8::Isolate::new(v8::CreateParams::default());\n// Create a stack-allocated handle scope.\nlet handle_scope = &mut v8::HandleScope::new(isolate);\n// Create a new context.\nlet context = v8::Context::new(handle_scope, Default::default());\n// Enter the context for compiling and running the hello world script.\nlet scope = &mut v8::ContextScope::new(handle_scope, context);\n// Create a string containing the JavaScript source code.\nlet code = v8::String::new(scope, \"'Hello' + ' World!'\").unwrap();\n// Compile the source code.\nlet script = v8::Script::compile(scope, code, None).unwrap();\n// Run the script to get the result.\nlet result = script.run(scope).unwrap();\n// Convert the result to a string and print it.\nlet result = result.to_string(scope).unwrap();\nprintln!(\"{}\", result.to_rust_string_lossy(scope));\n}\ndeno_core\nThe deno_core\ncrate, builds on Rusty\nV8. Where Rusty V8 is truly exposes V8’s C++ API as directly as possible in\nRust, deno_core\nadds “ops” and an event loop. Practically it maps JavaScript\nPromises onto Rust Futures. The “ops” are marcos which allow users to define\nfunctions that cross the boundary between JavaScript and Rust as efficently as\npossible (using V8’s Fast API where possible).\nWe’ve written some\nblog posts about how\none can use deno_core\nto quickly roll your own JavaScript runtime.\nAlthough deno_core\nadds a lot on top of Rusty V8, it still lacks many things\nfrom the main deno runtime - it has no concept of TypeScript, it has very few\nAPIs - no fetch()\n- and certainly no built-in node modules.\nrust-urlpattern\nThis crate implements the\nURLPattern\nweb API in Rust, following the specification as closely as\npossible. We use this …\nuse urlpattern::UrlPattern;\nuse urlpattern::UrlPatternInput;\nuse urlpattern::UrlPatternInit;\nuse urlpattern::UrlPattern;\nuse urlpattern::UrlPatternInit;\nuse urlpattern::UrlPatternMatchInput;\nfn main() {\n// Create the UrlPattern to match against.\nlet init = UrlPatternInit {\npathname: Some(\"/users/:id\".to_owned()),\n..Default::default()\n};\nlet pattern = <UrlPattern>::parse(init).unwrap();\n// Match the pattern against a URL.\nlet url = \"https://example.com/users/123\".parse().unwrap();\nlet result = pattern.exec(UrlPatternMatchInput::Url(url)).unwrap().unwrap();\nassert_eq!(result.pathname.groups.get(\"id\").unwrap(), \"123\");\n}\nimport_map\nimport_map\nis a Rust crate\nimplementing the WICG Import Maps specification. An import map is a JSON file\nthat lets you control how module specifiers resolve to actual URLs in JavaScript\nand TypeScript. We use this library to parse and apply import maps.\nYou can use import_map\nto create and map custom specifiers like \"my-lib\"\nto\na full URL:\nuse import_map::ImportMap;\nuse url::Url;\n// Define a base URL for relative mappings.\nlet base_url = Url::parse(\"file:///project/\").unwrap();\n// Create a new import map with a simple mapping:\nlet mut import_map = ImportMap::new(base_url);\nimport_map.imports_mut().insert(\n\"my-lib\".to_string(),\nUrl::parse(\"https://cdn.example.com/my-lib@1.0/mod.js\").unwrap()\n);\n// Resolve a specifier using the import map.\nlet specifier = \"my-lib\";\nlet resolved_url = import_map.resolve(specifier, &base_url).unwrap();\nprintln!(\"'{}' resolves to {}\", specifier, resolved_url);\neszip and eszip_viewer\nThe eszip\nformat lets you losslessly\nserialize an ECMAScript module graph into a single compact file, allowing\nefficient storage and transmission of code as a single package. This is useful\nfor creating standalone archives of JavaScript or TypeScript projects, or\ncaching module graphs. It also supports streaming, so large module bundles can\nbe loaded efficiently.\n# Bundle a Deno module (and its dependencies) into an eszip file:\n$ cargo run --example eszip_builder https://deno.land/std/http/file_server.ts file_server.eszip\n# Later, view the contents of that eszip archive:\n$ cargo run --example eszip_viewer file_server.eszip\n# You can even execute the bundle by loading it into a V8 runtime (using an eszip loader).\n$ cargo run --example eszip_load file_server.eszip https://deno.land/std/http/file_server.ts\nWe use eszip\nfor quickly loading JavaScript and TypeScript in Deno Deploy. We\nalso have eszip_viewer\nto easily\nview eszip\nformats.\nsui\nsui\nis a Rust library (named after the\nHindi word for “needle”) that lets you embed data into executable files (ELF on\nLinux, PE on Windows, Mach-O on macOS), which can be extracted later. This is\nuseful for bundling assets or configuration inside a binary without external\nfiles. sui\nproduces valid executables that can be code-signed on macOS and\nWindows.\nWe use sui\nin deno compile\nto minimize binary size and for code signing.\ndnt\ndnt\n(Deno to npm transform) is\na build tool that converts a Deno module into a format publishable to npm\nby shimming Deno-specific globals, rewriting import statements, and outputting\ntypes and CommonJS versions. This allows module authors to easily publish hybrid\nnpm modules for ESM and CommonJS.\nHere’s an example of using dnt\nin a build script to package your ES module:\n// scripts/build_npm.ts\nimport { build, emptyDir } from \"jsr:@deno/dnt\";\nawait emptyDir(\"./npm\"); // clear output directory\nawait build({\nentryPoints: [\"./mod.ts\"], // your Deno module entry\noutDir: \"./npm\", // output directory for the npm package\nshims: {\ndeno: true // shim the Deno namespace for Node\n},\npackage: {\nname: \"your-package\",\nversion: \"0.1.0\",\ndescription: \"Your package description\",\nlicense: \"MIT\",\nrepository: {\ntype: \"git\",\nurl: \"git+https://github.com/yourname/your-repo.git\"\n}\n// ... other package.json fields as needed\n}\n});\n// After this script runs, the \"./npm\" folder contains a package.json, README, and the transpiled code ready to publish.\nwasmbuild\nThis CLI\nsimplifies the process of building and using Rust code in Deno and the browser.\nIt generates glue code for calling into Rust crates via wasm-bindgen\n. The\noutput can be easily consumed in Javascript via Wasm. This tool is great in\nsituations where you might want to call a complex algorithm in Rust from\nJavaScript, or run Rust code that is more efficient than in JavaScript.\nFor a more full example, check out\nwasmbuild_example\n.\nmonch\nThis rust crate is a light-weight parser\ncombinator library inspired by nom\n. It was\ncreated to provide a more targeted library for parsing strings and added some\ncombinators we found useful. In Deno, monch\nis used to parse the deno task\ncommand strings and other similar situations.\nuse monch::*;\nfn parse_comma_separated(input: &str) -> ParseResult<'_, Vec<&'_ str>> {\nlet word = map(take_while(|c| c != ','), |v| v.trim());\nlet comma = ch(',');\nseparated_list(word, comma)(input)\n}\nlet parse = with_failure_handling(parse_comma_separated);\nprintln!(\"{:?}\", parse(\"apple, banana ,pear \")); // Ok([\"apple\",\"banana\",\"pear\"])\ndeno_task_shell\ndeno_task_shell\nis a\ncross-platform shell implementation for parsing and executing scripts. We use\nthis in deno task\n.\n// parse\nlet list = deno_task_shell::parser::parse(&text)?;\n// execute\nlet env_vars = std::env::vars_os().collect::<HashMap<_, _>>();\nlet cwd = std::env::current_dir()?;\nlet exit_code = deno_task_shell::execute(\nlist,\nenv_vars,\ncwd,\nDefault::default(), // custom commands\n).await;\nflaky_test\nflaky_test\nis a Rust attribute macro\nthat helps manage flaky tests by running a test multiple times and only failing\nit if it fails every time. This is useful for tests that are known to be flaky\n(due to non deterministic issues like network or availability). By default, the\nmacro runs the marked test three times. If at least one run passes, the overall\ntest is considered passed.\nuse flaky_test::flaky_test;\n#[flaky_test]\nfn my_unstable_test() {\n// This test will be tried up to 3 times.\nlet result = some_operation_that_sometimes_flakes();\nassert!(result.is_ok());\n}\nvnotify\nvnotify\n(short for “vectorized\nnotification”) is a Rust library for efficiently monitoring changes in Amazon S3\nbuckets that contain millions of objects. It achieves this without any external\nservices using a clever hashing strategy: when an object in S3 is updated,\nvnotify\nwrites a small notification file under a special prefix. Clients can\nquickly check a fixed set of these notifications to detect updates across the\nwhole bucket with one or two S3 API calls. This is useful for caching or syncing\nscenarios where you want to know if any object in a huge bucket changed without\nscanning the entire bucket.\nuse aws_sdk_s3::Client;\nuse vnotify::{VnotifyCache, Config};\nuse bytes::Bytes;\n// Set up the S3 client and vnotify configuration.\nlet s3_client = Client::new(&aws_config::load_from_env().await);\nlet config = Config::new(\"my-bucket-name\".to_string(), \"vnotify_prefix/\".to_string());\nlet cache = VnotifyCache::new(s3_client, config);\n// Signal an update (writer side) – for example, after modifying \"path/to/object\".\ncache.put(\"path/to/object\", Bytes::from_static(b\"1\")).await?;\n// (The content '1' is arbitrary; the key's ETag changing is what signals a change.)\n// Later, a reader can quickly check if *any* object changed by checking the special \"_\" key:\nif cache.try_get(\"_\").await?.is_some() {\nprintln!(\"Some object in the bucket changed, need to refresh cache.\");\n// The client could then list \"vnotify_prefix/\" keys to find out which segment changed.\n}\nWhat’s next\nThese open source projects not only power Deno, but also used across the broader developer ecosystem. We’ll continue to build tools that make development simpler and more secure, and hope you’ll explore and build something great with them.", "url": "https://wpnews.pro/news/deno-s-other-open-source-projects", "canonical_source": "https://deno.com/blog/open-source", "published_at": "2025-10-16 16:00:00+00:00", "updated_at": "2026-05-22 12:23:29.957740+00:00", "lang": "en", "topics": ["open-source", "developer-tools", "products"], "entities": ["Deno", "rusty_v8", "deno_core", "rust-urlpattern", "import_map", "eszip", "sui", "dnt"], "alternates": {"html": "https://wpnews.pro/news/deno-s-other-open-source-projects", "markdown": "https://wpnews.pro/news/deno-s-other-open-source-projects.md", "text": "https://wpnews.pro/news/deno-s-other-open-source-projects.txt", "jsonld": "https://wpnews.pro/news/deno-s-other-open-source-projects.jsonld"}}