See the entire conversation

What should we improve or add in a future Deno release that would make you say “FINALLY”?
231 replies and sub-replies as of May 21 2022

http benchmark showing that Deno is faster than node. Also, bytecode caching could be nice.
FFI callbacks 👀
ARM (RPi) build!
can deno run TS transpilers? i.e : esbuild, webpack, etc...
Yes, you can use esbuild with Deno:…
Vite should already run with Deno's compat mode. Give it a try!
That's sounds interesting. What other node build tools do you support already or intend to support in the future?
Framework like Nest.js
I like the idea of Deno offering everything you need to build a project, similar to Cargo for Rust. The biggest of which for me atm would be a "new" subcommand to bootstrap a new project structure
What would you want this command to bootstrap?
I guess a recommend initial project structure like `cargo new` or `cargo new --lib` does. So a `deno.json`, `import_map.json`, `.gitignore`, initialize git & a basic function export with a test to validate?
This can be used to build a deno script with a main.ts file which can either be executed directly as s command via deno run, via deno install or can even be bundled or compiled to be used as cli or Npm package
In the end, I see a better fit for these generators as deno modules in userland. One could start an „Awesome“ Repo to curate the best generators for deno repos, maybe even curated by the deno team to give them extended visibility :)
All of these look great & tbh if there was a `deno new` command to generate one of these project types it would be ideal. EG: `deno new --module`, `deno new --script`, `deno new --cli`, etc The closest I have built atm is this:
GitHub - NuroDev/deno-module: 🦕 Template repository to help bootstrap a new Deno module
🦕 Template repository to help bootstrap a new Deno module - GitHub - NuroDev/deno-module: 🦕 Template repository to help bootstrap a new Deno module
And a tsconfig.json with sane defaults
Demo ships with sane TS defaults out of the box. In most cases you don't need to change any TS settings
This. Please help us bootstrap new projects with the most minimal amount of files and content needed to get it working. I don't have the time to look for the correct packages (if any) and the structure of whatever permissions/commands I need.
Prisma/fastify for Deno
is working on Prisma integration
When there is at least an alpha release i will say FINALLY 🚀
An alternative to Electron
Would integration with Tauri solve your use case?
Honestly it looks pretty complicated, so I don’t think so.
Tauri is super easy to use, and I've had a better experience so far than I did with Electron. I'd love to see Deno work with Tauri.
I spoke too soon, I should try it… I just see stuff about XCode and whatnot and it makes me nervous.
I think the only XCode related thing is just a single command to install the dependencies. But other than that, it's all JS (and optionally a bit of rust).
Yes, there are some OS-specific dependencies that need to be installed. The rest is easy :-))
the logo should represent the strength and security of the available features
Support for JSI could be sweet
Deno supports spawning child processes, you can use… APIs for it
Project bootstraping like npx… “deno create lume-site@1.9.0 blog”
proper packages & versions management, not considering packages as a reality is very problematic. it has a lot of security & productivity implications, modules are not a good distribution unit.
A package manager 😏
deno as such you don't need a package manager but if you need close to npm experience you can see: or
It needs to be official
Deno don’t need packages manager
brilliants of Deno is no need packages and managers
Yes, and that's great, but some way of automatically managing versions of imports spread across a project. A tool that with one command would find and add a module to an import map, and manage versions would be nice. This thread introduced me to trex, which seems good
But I need a package manager.
having a tool that turns package.json into an import map would be very nice
built in modern ssr
finally 😁 great project💪 I'm waiting for production ready and take a taste
A way to get debug logging. I’d like to know if deno is downloading modules to the cache. There’s also moments where deno is frozen during startup doing something but I have no idea what. Having some visibility into that would help.
Deno always print "Download ..." messages when it is downloading module from the internet. As for the "frozen" during startup; do you see "Check ..." prompt before this freeze happens?
True but there’s no time stamp in the log line, so it’s difficult to tell how long that step took.
Can you open an issue about it with some details what this feature should support?
Custom JSX transform.
Can you elaborate?
I would like to use Solid.js with Deno. Would be awesome if we could plug in a custom AST transform for JSX.
Agreed. I feel like @solid_js & @deno_land could be a dream combo! 💪
Isn't it @davedbase wet dream? 🤔
YES PLEASE! This would be so freaken awesome.
But seriously, a Solid future would surely involve Deno. We need a modern runtime for a modern reactive UI library. Super, duper bullish on Deno.
I'm sure we can figure something out to support Solid in Deno
I could probably rally some of our community support. Let me know how I can help make this happen. Our Discord is VERY helpful and opinionated as well.
Deno supports custom JSX factories, including the "new" JSX runtime. There are multiple libraries that "just work" with Deno. Better "out of the box" support though for SolidJS would be good, but likely the fundamentals are in place already.
Deno - A modern runtime for JavaScript and TypeScript
Deno is a simple, modern runtime for JavaScript and TypeScript that uses V8 and is built in Rust.
Unfortunately, this is not sufficient, as these fundamentals don’t really help. Solid performs AST transformations that the “new” JSX runtime doesn’t allow for. To support Solid, Deno must allow for something like SWC plugins.
deno as such you don't need a package manager but if you need close to npm experience you can see: or
Oh That's The Thing That I Don't Know Thanks For This Suggestion..
package-level permissions instead of process level. I would 100% switch to deno if I could allow the filesystem, but only for the main module, not all subsequents node_modules inside it. That would prevent most malicious JS modules right?
This has been discussed multiple times and we haven't come up with a way to do that would actually be secure. @lcasdev can say more about it
Yeah that one sounds tricky tbh. I'll be glad to read a little more on the subject, and see the options you've considered if you have a link or something.
Are there any web proposals in the works that might help with this? If not, could the Deno org/company perhaps lead a proposal or start some serious discussion around it? Or is it just fundamentally infeasible?
With the current state of JS, it is fundamentally infeasible to do securely. There is work in TC39 to make this possible eventually (…). This work is being led mostly by folks at Agoric
GitHub - tc39/proposal-ses: Draft proposal for SES (Secure EcmaScript)
Draft proposal for SES (Secure EcmaScript). Contribute to tc39/proposal-ses development by creating an account on GitHub.
I sympathize with the hard realities. OTOH I never invested time into Deno because I couldn't get past how coarse access control is - what is the practical use case for it being that way? What I want is something like where module isolation is built-in.
Lunatic - An Erlang-inspired runtime for WebAssembly
Lunatic is an open-source WebAssembly runtime and platform for running server-side applications
I think this would make people mass adopt deno. No other platform supports this and it's really important feature in these days
No type checking by default but that's already coming.
Yep! In v1.23, next month, "deno run" will no longer type-check by default.
That's crazy. Definitely something that will prevent me from using it.
Because I use TypeScript due its type-checking. If it is disabled per default, there's no point in using TypeScript for me. That's like disabling type-checking in gcc per default and let the IDE instead try to cover it.
You'll still be able to use it with --check flag and commands like "deno test" and "deno bench" will still type check by default
Meh, sure. It's workaround to a fundamental problem of TS being slow. I'm more the type who solves problems fundamentally rather than pushing them away. A type checker in a fast language is the way to go instead of hiding type checking behind a flag.
That is most likely not true. Even the TypeScript team is skeptical using a "fast" language would provide significant speedups.
Converting the architecture used to type check in the current type-checker won't give any substantial performance improvements when written in another language, that's correct. But there are other architectures like converting to byte-code and run in a VM that has not been tested
What alternative POV should that give me regarding type checking?
Basically that type checking is a form of linting but it's up to you how you interpret it.
Certainly, the same could be said about other type-checkers in other languages. But that doesn't mean I'm in favor of disabling them by default.
I don't think you can just lint C# or Java, TypeScript is special in this.
Not sure what you're trying to say, but GCC supports "lint-only", so does Go. I've no knowledge about c#/java. But it's more about the opposite, isn't it?: Let gcc/go compile without telling you any errors, so you only see them at runtime as a segfault.
Go supports lint-only, i.e., it can run an incorrectly typed code? That's news to me.
Exactly, that's not possible - for good reasons. Yet, Deno not only allows that, it makes it a default.
You can't claim that Go is lint-only and the opposite at the same time. Please make up your mind.
Lint-only mode doesn't mean it runs incorrectly typed code. Go/gcc can "lint" only, correct. They can't compile incorrectly typed code, correct. Both are correct.
> Lint-only mode doesn't mean it runs incorrectly typed code. It does. Deno (and e.g. Next.js) can run incorrectly typed code. It's the whole point.
I think we refer to different "it". I can lint-only my C++ code, but that doesn't mean it will compile and run. But the whole point is that Deno allows me (per default) to run completely incorrectly typed code, whereas gcc/Go do not - for good reasons.
database support. only thing making me use deno not as often as i wish i could
Are you talking about missing DB drivers? Which DBs do you want to use?
especially mongodb
Deno has mongo db driver. Try this one
anyone know if oracledb is supported?
Code signing and verification
Something like yarn workspaces in yarn, maybe something already exist but I have never found it
a boiler-plate for a full-stack app. Just create-deno-fullstack and a repo with full backend-frontend capability is ready to be spin up!
Permissions for imported packages
package-level permissions instead of process level. I would 100% switch to deno if I could allow the filesystem, but only for the main module, not all subsequents node_modules inside it. That would prevent most malicious JS modules right?
Seems like a miss that you can't do this.
Even more options for sandboxing: - V8 flags for workers, for limiting memory usage, for example. For processor I know it's hard. - importmap for workers or a way to limit imports to a specific folder.
Being able to mix deno + non-deno code in the same repo/workspace. i.e. better VSCode tooling to support this case. I'd love to incrementally move to deno, but I need my frontend code to be written with "traditional" TS still.
That's cool! I didn't know that existed, I'll give it a try. To share this setup with other devs, though, I would have to check in vscode settings to the repo. Might be nice to have an alternative like a `#!` file header or a per-folder configuration.
Also, I'd love to have native support for deno in AWS Lambda/cloud functions. But that's less of a feature thing.
Proper dependency management
try/catch /s
Automatic cookie handling in the Fetch API, like the browser. I know there’s the “another_cookejar” module, but I’d trust in built-in functionality more.
In the bigger scheme of things, Deno needs to be an order of magnitude better than node. If that’s not happening, the migration won’t be happening either as it’s more difficult to break the status quo than just being first.
I don’t think that Deno will replace Nodejs, they’ll live along each other. There won’t be a migration but people will chose their favorite. As an example, I don’t think that angular/react teams will migrate so nodejs will still be chosen for these.
Merge the NAPI PR.
you heard it, now we need to merge it 😛
What's that?
Deno doesn't currently do anything for browser bundling. Other Remix team members have more context on this, but we had a hard time using what Deno offers out of the box to ship something that worked on both the server and in the browser.
They are talking about fresh, not Deno :)
I know. Remix *already* supports Deno. :) I just think it'd be cool if Deno thought a bit about apps that run on both the server and client.
Vite should already run with Deno's compat mode. Give it a try!
Oficial ARM builds for raspberry :D
Single-letter aliases for "allow" flags other than "--allow-all".
Configuring the "log-level" for console.{debug, info, warning, error} statements.
I would like to see a flag for deno-run to set the logging level. And have the console commands respect that. Maybe even expose it as part of the Deno namespace to let logging libraries respect it as well.
It's not really a Deno, but more of the issue of the ecosystem. I want to be able to run projects based on CRA/next.js/astro/remix without installing node. You still need node right now to build a project to run on Deno/Edge :)
I think the problem here is, that deno is able to distribute typescript based binaries, but for the compiled tooling we need to fall back to the known OS level package managers. This means, someone should setup some kind of package manager in style of brew but cross platform 😂
Maybe better (or worse) idea: write a clone of npm or a mvp of that which runs on deno. This way we can could simply use the npm package ecosystem from node. We could also limit the use packages exporting binaries. The very least we could re-use the node tar.gz packages.
API to run ast transforms before execution
Can you expand a little bit on what you mean?
At @QwikDev we are working to get a great integration with Deno (in local development) and also for edge runtime. Qwik needs to run some transforms to the code before executing, and deno seems to lack a simple plugin system to inject this in a transparent way. cc @lcasdev
Support for setting memory limits on workers
Files embedded right into the compiled file. Currently I have to objcopy them into the file.
Is there a bench that compares deno to cloudflare workers? I need to know bootstrap time, memory etc.
I think what could push it over the top for more adoption is not really a feature added but having more creators creating video tutorials on how to use Deno on YouTube. Say how to create applications with Deno. Just my thoughts.
Haven't checked in on Deno in a while, love it tho. So not sure current status. Apologize ignorance: Deno has the right security model. Could it also run WebWorkers & non-DOM WebGL wrapper? Even headless? I ask because of @SecureRender.
Deno has web workers, and experimental WebGPU support. No intention by core team to implement WebGL at this point AFAIK, but likely will get implemented in userland on top of WebGPU when it stablises (I'd guess that someone is already working on this)
Woah! Wow. Humbled and grateful people are working on that. Even better. I'm excited for the future!
Deno is awesome! There are only a few things I wish Deno had: 🤏 --minify option for `deno bundle` 🔐 JsonWebToken in Standard Library 🍃 MongoDB ODM (Happy to see DangoDB is being released) 🔺 Prisma and ⚛️ Electron alternatives
Do you have support for HTTP integration tests?
Please elaborate. We have a lot of testing helpers in deno_std. In most cases using "fetch" API is enough for such tests
100% backward compatibility of nodejs
It's not about the CLI, but: Type stripping when is serving to the browser. The pull request is ready to go if a lazy-transpilation approach is viable:
feat(registry): Add on the fly compilation by AnInternetTroll · Pull Request #1902 · denoland/dotland
fixes #1728
Compiling to native binary like Rust, currently the binaries are too big for a simple hello world app, but that's a huge amount of work though
a native database driver as jdbc in java, package manager, http3/quic
A native react-like (or vue/svelte) frontend framework, personally I don't like to have to pass through
Very fast execution of unit tests
Is the current speed of "deno test" not fast enough?
Yeah, I don't think it's too slow. I like that it skips the typechecker. I meant that enabling very fast iteration is something that's appealing about deno.
Native AWS Lambda integration.
DOT Products / Matrix Math
A JDBC(java)-like database driver API
Limiting network bandwidth. I know it’s possible to limit cpu and memory via cgroups but network is different.
speed , still node is fast more than half use case
work seamlessly with nodejs packages 🤷
Official package manager with node-style import statements.
Some examples of a frontend app - how to run react / vue (eg using vite) Deno still feels a “backend side language”
How is WebAssembly (I mean, importing ES modules written in TypeScript, compiled to Wasm)? That'd be game changer!
Are you thinking of AssemblyScript?
Something like npm ? 📦 👌🏿
Package permissions which allow you to set permissions for a package and all its children, along with the ability to “pass through” permissions. (I.e. give it c via b)
For example, import package b but give it permission to do nothing, but package c included inside b, that can have filesystem access.
package-level permissions instead of process level. I would 100% switch to deno if I could allow the filesystem, but only for the main module, not all subsequents node_modules inside it. That would prevent most malicious JS modules right?
Object capability security model for packages
Permissions per package and all its children
Async import on deno deploy
Get FFI support to stable, automatic bindgen with C libraries, and passing callbacks through FFIed functions. Would make developing our GTK Deno bindings a lot easier ;)
Just recently use deno for authoring a lib and really love it if `deno bench` measure memory and obj-allocs statistics too
A reason to exist. By now, most of the people who were starting to become dissatisfied with Node moved to Golang. Everyone who stuck with Node stuck with it primarily for things like ecosystem and familiarity. What does Deno offer that’s so great compared to either Node or Go?
I know you may be asking me what the current year is, IIS hosting module?
VM Context execute Javascript
Native node_modules/ folder support. (I know, I know. You can skip your lecture.)
I know I might get scolded for this, but a fully working node.js compatibility layer, so you don't have to do without most of the well-established js ecosystem when switching to deno. I'd love to be able to use deno with frameworks like nextjs
Performance 10x better then nodejs. Otherwise there is no incentive of using deno tbh.
I find package manager as a good entry point when starting with a new codebase to understand what packages it is using. how do you do that with deno? is it possible??
Socks proxies for websockets
npm compatiblity
- Something like Tauri built in Deno - Optional compatibility with npm packages with --allow-npm - Anything to make migrating from Node more seamless - Something like nodemon -w ./src/*/*.ts built in, like deno --watch Haven't touched Deno in months. Maybe it's already there.
Official bazel rules maybe, instead of package manager
A proper built-in dependency manager
Low level TLS stuff such as accessing information inside ClientHello.
Don't sell yourself to OpenJS Foundation