{"article":{"slug":"im-not-a-fan-of-denos-security-model","title":"I'm not a fan of Deno's security model","subtitle":null,"summary":"A post on max's place argues that Deno's permissions system is fundamentally insecure and misleading: coarse runtime flags cannot isolate untrusted code, and something like bubblewrap is a better sandbox than asking users to approve broad filesystem or network access.","content_type":"opinion","language":"en","canonical_url":"https://goldstein.lol/posts/deno-security/","author":{"name":"max","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"max's place","url":"https://goldstein.lol/","listing_slug":null,"listing":null},"topics":[{"name":"Security","slug":"security","url":"https://listedarticles.com/topics/security"},{"name":"Programming","slug":"programming","url":"https://listedarticles.com/topics/programming"}],"about_listings":[{"slug":"deno","name":"Deno","listing_type":"company","url":"https://listedstartups.com/companies/deno"}],"cover_image_url":null,"license":"all-rights-reserved","word_count":1956,"reading_minutes":9,"published_at":"2024-08-31T00:00:00.000Z","added_at":"2026-11-08T17:12:03.152Z","updated_at":"2026-11-08T17:12:03.152Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/im-not-a-fan-of-denos-security-model","markdown_url":"https://listedarticles.com/articles/im-not-a-fan-of-denos-security-model.md","example":false,"citation":"max, max's place. \"I'm not a fan of Deno's security model.\" 31 Aug 2024. https://goldstein.lol/posts/deno-security/ (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://goldstein.lol/posts/deno-security/"},"body_markdown":"# I’m not a fan of Deno’s security model\n\nthis has been bothering me for a while now, so I want to write down my thoughts so I can get it out of my head and move on. we’re gonna talk about how Deno approaches security, specifically with its permissions system, and why I think this approach is fundamentally insecure and misleading.\n\n## wait, what’s Deno?\n\n[Deno](https://deno.com) is a language runtime for JavaScript. it consists of a standard library, a package manager,\na TypeScript transpiler and a bunch of other stuff that’s not important for our story. it’s not\na JavaScript *implementation*, so it does not interpret or compile JavaScript, it reuses V8 for that.\n\none of the flagship features of Deno is its permission system\n(it’s under the “Secure by default” header on their [landing page](https://deno.com)).\nthe idea is simple: as JS code running in Deno needs the standard library to access the outside world,\nDeno can choose which accesses it allows or disallows, so when you run\n\n`shell``deno run --allow-read=/tmp/dir --allow-run=uname code.ts`\nthe standard library will only allow `code.ts` to read `/tmp/dir` and run `uname`.\n\nadditionally, a program can request permissions at runtime, so code like\n\n`typescript````\nconst r = { name: \"read\", path: \"/tmp/dir\" } as const;\nawait Deno.permissions.request(r);\n```\nwill display a nice little prompt in the terminal:\n\n```\n┌ ⚠️  Deno requests read access to \"/tmp/dir\".\n├ Requested by `Deno.permissions.request()` API.\n├ Run again with --allow-read to bypass this prompt.\n└ Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions) > \n```\nand you can grant or refuse it.\n\n(aside: I really miss this feature in browser extensions. currently, if your extension needs *potential*\naccess to *any* website, it needs to request *actual* access to *all* the websites, which is less than ideal)\n\nif you like puzzles, this is the point where you can stop and think about what could go wrong with this system.\n\n## the prompts problem\n\nof the two specific issues I want to point out this is the less severe one. we’ll discuss it first because this was the first thing I noticed and it kinda immediately irked me when I first read about this.\n\n(if you’re only interested in the more juicy part, you can skip to the [next section](#the---allow-run-problem)).\n\nso, this nice little prompt is displayed in the terminal. it’s not, like, a PolKit GUI window or anything, it’s just text on stdout waiting for input from stdin. this is a wild thing to do.\n\nyou see, terminal has a somewhat weird API. most of the commands / requests application can send to the terminal\nare sent in-band, by printing them to stdout. terminal can then reply by sending data to stdin.\nas Deno allows programs to print arbitrary data to stdout and read from stdin without requiring any permissions\nor doing any filtering, malicious code can send arbitrary commands to the terminal. it’s usually okay,\nbecause terminals won’t, like, execute shell commands just because stdout told them to, you’re supposed\nto be able to freely `cat` files without risking arbitrary code execution. it’s markedly less okay if\nyou allow malicious code to do whatever with the terminal and then print a prompt on the same exact terminal.\n\nyou could, like, [hide the prompt by messing with terminal colors](https://github.com/denoland/deno/issues/9666).\n(this one got closed in 2026 because the permission prompt is “partially visible”\n(you can see an emoji) and “AI agents tend to” change terminal colors, so that’s a “valid use-case”)\n\nor [trick the user into pre-feeding approval into stdin](https://github.com/denoland/deno/issues/9750).\n\nor [trick the terminal into feeding approval into stdin as a response to some request](https://github.com/denoland/deno/issues/9750#issuecomment-796702901).\n(terminal won’t ever send Enter to stdin to avoid executing commands, but “press Enter to continue”\nis common enough to not be suspicious; the user never sees the actual prompt).\nhere’s [an asciicast of that](https://asciinema.org/a/9rvK8ANJK0WnQc9nsrFKdC7ir),\nI think it looks quite cool.\n\nthe specific issue on the screencast is long patched; the issue with terminal colors is not.\nthat doesn’t really matter because the *real* issue is using an attacker-controlled channel for\nsecurity-sensitive information. it’s like executing attacker-controlled JS code on a webpage\nand then asking for password on the same page. you can’t know that the page is in a safe state,\nso you can’t trust any input.\n\neven if Deno manages to patch every single issue with the “standard” escape codes, you never know which non-standard codes even exist out there. many terminals have some, it’s impossible to predict how they will interact with your prompt.\n\n(aside: how come sudo can do it then? the difference is that sudo asks for the password first,\nbefore running any other code. to trick sudo that way you’d need to fuck up terminal state before\nyou even type `sudo`, and do it quietly enough that you don’t notice it while you type it.\nif some terminal allows it, I’d consider it a bug in the terminal)\n\n[the](#the---allow-run-problem) \n\n## the `--allow-run` problem\n\nso, there’s a weird thing with this command I wrote above (I’ll copy it here for reference):\n\n`shell``deno run --allow-read=/tmp/dir --allow-run=uname code.ts`\nwhat does `--allow-run=uname` even mean? it’s not like programs have canonical names, it’s not `org.gnu.coreutils.uname`,\nit’s not even `/nix/store/8k1dmzr3gwzqdgw45nzj76902ca7g1is-coreutils-full-9.5/bin/uname`. it’s just a shortcut for\n“look at all the directories in `PATH` one-by-one to see if you can find `uname` there”.\n\nyou can set environment variables for the child process without needing any extra permissions, so what if we just\n\n```\n$ cat t.ts\nconst command = new Deno.Command(\"uname\", {\n  // my current working directory, can be anything\n  env: { 'PATH': '/tmp/tmp.7ofmKaNW83' },\n});\nconst { code, stdout, stderr } = command.outputSync();\nconsole.log(new TextDecoder().decode(stdout));\n$ cat uname\n#!/bin/sh\nprintf lol\n$ deno run --allow-run=uname t.ts\nlol\n```\nyeah.\n\nonce again, we have a pretty and convenient interface that doesn’t really make sense from the security standpoint.\nit would be *nice* if programs were uniquely identified by their names, but they’re *not*, and pretending they are\nleads to security holes.\n\nfunnily enough, I didn’t even think that this issue would be there when I poked at Deno for the first time,\nso I haven’t reported it [until now](https://github.com/denoland/deno/issues/11964#issuecomment-2322993158) (spoiler alert: this is a comment on a GitHub issue\nthat I created for the problem I’ll explain below).\n\nso let’s imagine we fixed that. it’s not *that* hard, we can force `PATH` to be whatever it was when the runtime started,\nor always require fully-qualified paths, or prompt with a fully-qualified path before running. are we safe now?\n\nlol no of course we’re not. while `PATH` decides which executable gets run, dynamically-linked executables (so, like, most executables)\nrequire dynamic loader to actually start. dynamic loader is a program that, well, loads the executable into memory, finds its\ndependencies and does a bunch of other fun stuff we won’t get into. the important part is that dynamic loader is *configurable*\nvia environment variables. you can probably see where this is going now.\n\n`LD_PRELOAD` instructs the dynamic loader to load specific dynamic library when loading executables.\ndynamic libraries can execute arbitrary code on load.\nwe can just pass `LD_PRELOAD` and we’ve completely escaped the sandbox once again:\n\n```\n$ cat t.c\n#include <stdio.h>\n// ask dynamic loader to run this function on load time pretty please\n__attribute__((constructor)) void lol() {\n    puts(\"lol\");\n}\n$ cat t.ts\nconst command = new Deno.Command(\"uname\", {\n  // ask dynamic loader to load our evil library\n  env: { 'LD_PRELOAD': '/tmp/tmp.7ofmKaNW83/liblol.so' },\n});\nconst { code, stdout, stderr } = command.outputSync();\nconsole.log(new TextDecoder().decode(stdout));\n$ gcc -fPIC -shared t.c -o liblol.so\n$ # that's the real uname now!\n$ deno run --allow-run=uname t.ts\nlol\nLinux\n```\nI [reported this](https://github.com/denoland/deno/issues/11964) some time ago and now they [patched it](https://github.com/denoland/deno/pull/25271) by disallowing to set\nenvironment variables starting with `LD_`. this, once again, fixes a specific issue while ignoring the larger\nproblem: “permission to run a single command” is mostly not a useful concept.\n(you *can* do secure interfaces by allowing to run a single command, like git-over-SSH does,\nbut generally both the environment and the command need to be prepared to handle it)\n\nsay, for example, our script wants to invoke the `$EDITOR` so user can edit some data (think git commit messages).\nthat’s a very natural permission request, and it’s also an unmitigated disaster because most editors are\nconfigurable enough for running one to be a full sandbox escape. it’s easy for user to absent-mindedly\ngrant `--allow-run=vim` (“well, sure, I want to edit this file!”), but then the script can just set\n`VIMINIT='!rm -rf /*'` and oops, all my files are gone. most programs are configurable, often in some\nways you won’t think about (like `LD_PRELOAD`), and attacker controls the execution enviornment.\n“patch some specific ways to configure programs” is not the solution, the solution is to sandbox all the code,\nnot just JS code.\n\nwhen we discussed all this stuff in GitHub issues, a Deno developer wrote:\n\nThe main thing it protects you against is malicious code that isn't smart enough.\n\nupon reading this, I was enlightened.\n\n## conclusions\n\ndeno tries really hard to do what the operating system should be doing. it emulates syscall filtering by\nfiltering standard library calls. unfortunately, this breaks down the second you need to run code\nthat doesn’t use Deno standard library. it also uses somewhat flawed approach to permission management\nthat *looks* good (wow, runtime prompts! omg, I can just `--allow-run=uname`!), but introduces security\nrisks. in doing this, it implicitly requires user to understand all the implications of various permissions\nand their combinations, which can be really hard.\n\nDeno process is not actually sandboxed, it only pretends it is. I didn’t mention some more boring issues like “Deno doesn’t prevent you from following symlinks that lead outside of the sandbox” because they all just boil down to this simple one: the process is not sandboxed.\n\none can argue that this pseudo-sandboxing is better than nothing: after all, not all the malicious code is smart enough. I disagree: Deno permissions give a false sense of security and can lure someone into running untrusted code without proper sandboxing.\n\nit’s possible that you can use Deno sandboxing safely if you:\n\n- never use more dangerous permissions like `--allow-run` , even with`=cmd` ,\n- that includes `--allow-env` , even`--allow-env=VAR` , for setting environment variables is memory unsafe and can affect libc functions,\n- preferrably run with `--no-prompt` so your terminal can’t be tricked,\n- are careful about symlinks in directories you `--allow-{read,write}` to,\n- are not concerned with resource exhaustion: there’re zero permissions required to burn CPU or allocate memory.\n\nin particular, you may be safe if you’re running untrusted code with no permissions at all in a non-interactive context and use some other mechanism to control resource consumption.\n\nI still don’t think you *should* do it. this path is riddled with footguns because you’re\nexecuting untrusted code in a fully-privileged process, and the moment you need *some* OS interactions\nyou’re no longer running code “with no permissions at all”. you should not try to figure out which\nstdlib APIs can lead to a sandbox escape when combined. you should just use a proper sandbox.\n\nI’m not a fan of Deno’s security model.\n\n## so what do we do?\n\njust `bwrap` untrusted shit.\n\nalso, please: don’t harass Deno developers. we have a technical disagreement, but no technical disagreement was ever solved by harassment. this post is explicitly not an invitation to do it. I’ve already explained my point of view to them, they disagreed, and that’s okay. you don’t need to reiterate it, it won’t help anybody.","body_html":"<h1 id=\"i-m-not-a-fan-of-deno-s-security-model\">I’m not a fan of Deno’s security model</h1>\n<p>this has been bothering me for a while now, so I want to write down my thoughts so I can get it out of my head and move on. we’re gonna talk about how Deno approaches security, specifically with its permissions system, and why I think this approach is fundamentally insecure and misleading.</p>\n<h2 id=\"wait-what-s-deno\">wait, what’s Deno?</h2>\n<p><a href=\"https://deno.com\" rel=\"nofollow ugc noopener\">Deno</a> is a language runtime for JavaScript. it consists of a standard library, a package manager,\na TypeScript transpiler and a bunch of other stuff that’s not important for our story. it’s not\na JavaScript <em>implementation</em>, so it does not interpret or compile JavaScript, it reuses V8 for that.</p>\n<p>one of the flagship features of Deno is its permission system\n(it’s under the “Secure by default” header on their <a href=\"https://deno.com\" rel=\"nofollow ugc noopener\">landing page</a>).\nthe idea is simple: as JS code running in Deno needs the standard library to access the outside world,\nDeno can choose which accesses it allows or disallows, so when you run</p>\n<p><code>shell</code><code>deno run --allow-read=/tmp/dir --allow-run=uname code.ts</code>\nthe standard library will only allow <code>code.ts</code> to read <code>/tmp/dir</code> and run <code>uname</code>.</p>\n<p>additionally, a program can request permissions at runtime, so code like</p>\n<p><code>typescript</code>```\nconst r = { name: &quot;read&quot;, path: &quot;/tmp/dir&quot; } as const;\nawait Deno.permissions.request(r);</p>\n<pre><code>will display a nice little prompt in the terminal:\n</code></pre>\n<p>┌ ⚠️  Deno requests read access to &quot;/tmp/dir&quot;.\n├ Requested by <code>Deno.permissions.request()</code> API.\n├ Run again with --allow-read to bypass this prompt.\n└ Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions) &gt; </p>\n<pre><code>and you can grant or refuse it.\n\n(aside: I really miss this feature in browser extensions. currently, if your extension needs *potential*\naccess to *any* website, it needs to request *actual* access to *all* the websites, which is less than ideal)\n\nif you like puzzles, this is the point where you can stop and think about what could go wrong with this system.\n\n## the prompts problem\n\nof the two specific issues I want to point out this is the less severe one. we’ll discuss it first because this was the first thing I noticed and it kinda immediately irked me when I first read about this.\n\n(if you’re only interested in the more juicy part, you can skip to the [next section](#the---allow-run-problem)).\n\nso, this nice little prompt is displayed in the terminal. it’s not, like, a PolKit GUI window or anything, it’s just text on stdout waiting for input from stdin. this is a wild thing to do.\n\nyou see, terminal has a somewhat weird API. most of the commands / requests application can send to the terminal\nare sent in-band, by printing them to stdout. terminal can then reply by sending data to stdin.\nas Deno allows programs to print arbitrary data to stdout and read from stdin without requiring any permissions\nor doing any filtering, malicious code can send arbitrary commands to the terminal. it’s usually okay,\nbecause terminals won’t, like, execute shell commands just because stdout told them to, you’re supposed\nto be able to freely `cat` files without risking arbitrary code execution. it’s markedly less okay if\nyou allow malicious code to do whatever with the terminal and then print a prompt on the same exact terminal.\n\nyou could, like, [hide the prompt by messing with terminal colors](https://github.com/denoland/deno/issues/9666).\n(this one got closed in 2026 because the permission prompt is “partially visible”\n(you can see an emoji) and “AI agents tend to” change terminal colors, so that’s a “valid use-case”)\n\nor [trick the user into pre-feeding approval into stdin](https://github.com/denoland/deno/issues/9750).\n\nor [trick the terminal into feeding approval into stdin as a response to some request](https://github.com/denoland/deno/issues/9750#issuecomment-796702901).\n(terminal won’t ever send Enter to stdin to avoid executing commands, but “press Enter to continue”\nis common enough to not be suspicious; the user never sees the actual prompt).\nhere’s [an asciicast of that](https://asciinema.org/a/9rvK8ANJK0WnQc9nsrFKdC7ir),\nI think it looks quite cool.\n\nthe specific issue on the screencast is long patched; the issue with terminal colors is not.\nthat doesn’t really matter because the *real* issue is using an attacker-controlled channel for\nsecurity-sensitive information. it’s like executing attacker-controlled JS code on a webpage\nand then asking for password on the same page. you can’t know that the page is in a safe state,\nso you can’t trust any input.\n\neven if Deno manages to patch every single issue with the “standard” escape codes, you never know which non-standard codes even exist out there. many terminals have some, it’s impossible to predict how they will interact with your prompt.\n\n(aside: how come sudo can do it then? the difference is that sudo asks for the password first,\nbefore running any other code. to trick sudo that way you’d need to fuck up terminal state before\nyou even type `sudo`, and do it quietly enough that you don’t notice it while you type it.\nif some terminal allows it, I’d consider it a bug in the terminal)\n\n[the](#the---allow-run-problem) \n\n## the `--allow-run` problem\n\nso, there’s a weird thing with this command I wrote above (I’ll copy it here for reference):\n\n`shell``deno run --allow-read=/tmp/dir --allow-run=uname code.ts`\nwhat does `--allow-run=uname` even mean? it’s not like programs have canonical names, it’s not `org.gnu.coreutils.uname`,\nit’s not even `/nix/store/8k1dmzr3gwzqdgw45nzj76902ca7g1is-coreutils-full-9.5/bin/uname`. it’s just a shortcut for\n“look at all the directories in `PATH` one-by-one to see if you can find `uname` there”.\n\nyou can set environment variables for the child process without needing any extra permissions, so what if we just\n</code></pre>\n<p>$ cat t.ts\nconst command = new Deno.Command(&quot;uname&quot;, {\n  // my current working directory, can be anything\n  env: { &#39;PATH&#39;: &#39;/tmp/tmp.7ofmKaNW83&#39; },\n});\nconst { code, stdout, stderr } = command.outputSync();\nconsole.log(new TextDecoder().decode(stdout));\n$ cat uname\n#!/bin/sh\nprintf lol\n$ deno run --allow-run=uname t.ts\nlol</p>\n<pre><code>yeah.\n\nonce again, we have a pretty and convenient interface that doesn’t really make sense from the security standpoint.\nit would be *nice* if programs were uniquely identified by their names, but they’re *not*, and pretending they are\nleads to security holes.\n\nfunnily enough, I didn’t even think that this issue would be there when I poked at Deno for the first time,\nso I haven’t reported it [until now](https://github.com/denoland/deno/issues/11964#issuecomment-2322993158) (spoiler alert: this is a comment on a GitHub issue\nthat I created for the problem I’ll explain below).\n\nso let’s imagine we fixed that. it’s not *that* hard, we can force `PATH` to be whatever it was when the runtime started,\nor always require fully-qualified paths, or prompt with a fully-qualified path before running. are we safe now?\n\nlol no of course we’re not. while `PATH` decides which executable gets run, dynamically-linked executables (so, like, most executables)\nrequire dynamic loader to actually start. dynamic loader is a program that, well, loads the executable into memory, finds its\ndependencies and does a bunch of other fun stuff we won’t get into. the important part is that dynamic loader is *configurable*\nvia environment variables. you can probably see where this is going now.\n\n`LD_PRELOAD` instructs the dynamic loader to load specific dynamic library when loading executables.\ndynamic libraries can execute arbitrary code on load.\nwe can just pass `LD_PRELOAD` and we’ve completely escaped the sandbox once again:\n</code></pre>\n<p>$ cat t.c\n#include &lt;stdio.h&gt;\n// ask dynamic loader to run this function on load time pretty please\n<strong>attribute</strong>((constructor)) void lol() {\n    puts(&quot;lol&quot;);\n}\n$ cat t.ts\nconst command = new Deno.Command(&quot;uname&quot;, {\n  // ask dynamic loader to load our evil library\n  env: { &#39;LD_PRELOAD&#39;: &#39;/tmp/tmp.7ofmKaNW83/liblol.so&#39; },\n});\nconst { code, stdout, stderr } = command.outputSync();\nconsole.log(new TextDecoder().decode(stdout));\n$ gcc -fPIC -shared t.c -o liblol.so\n$ # that&#39;s the real uname now!\n$ deno run --allow-run=uname t.ts\nlol\nLinux</p>\n<pre><code>I [reported this](https://github.com/denoland/deno/issues/11964) some time ago and now they [patched it](https://github.com/denoland/deno/pull/25271) by disallowing to set\nenvironment variables starting with `LD_`. this, once again, fixes a specific issue while ignoring the larger\nproblem: “permission to run a single command” is mostly not a useful concept.\n(you *can* do secure interfaces by allowing to run a single command, like git-over-SSH does,\nbut generally both the environment and the command need to be prepared to handle it)\n\nsay, for example, our script wants to invoke the `$EDITOR` so user can edit some data (think git commit messages).\nthat’s a very natural permission request, and it’s also an unmitigated disaster because most editors are\nconfigurable enough for running one to be a full sandbox escape. it’s easy for user to absent-mindedly\ngrant `--allow-run=vim` (“well, sure, I want to edit this file!”), but then the script can just set\n`VIMINIT=&#39;!rm -rf /*&#39;` and oops, all my files are gone. most programs are configurable, often in some\nways you won’t think about (like `LD_PRELOAD`), and attacker controls the execution enviornment.\n“patch some specific ways to configure programs” is not the solution, the solution is to sandbox all the code,\nnot just JS code.\n\nwhen we discussed all this stuff in GitHub issues, a Deno developer wrote:\n\nThe main thing it protects you against is malicious code that isn&#39;t smart enough.\n\nupon reading this, I was enlightened.\n\n## conclusions\n\ndeno tries really hard to do what the operating system should be doing. it emulates syscall filtering by\nfiltering standard library calls. unfortunately, this breaks down the second you need to run code\nthat doesn’t use Deno standard library. it also uses somewhat flawed approach to permission management\nthat *looks* good (wow, runtime prompts! omg, I can just `--allow-run=uname`!), but introduces security\nrisks. in doing this, it implicitly requires user to understand all the implications of various permissions\nand their combinations, which can be really hard.\n\nDeno process is not actually sandboxed, it only pretends it is. I didn’t mention some more boring issues like “Deno doesn’t prevent you from following symlinks that lead outside of the sandbox” because they all just boil down to this simple one: the process is not sandboxed.\n\none can argue that this pseudo-sandboxing is better than nothing: after all, not all the malicious code is smart enough. I disagree: Deno permissions give a false sense of security and can lure someone into running untrusted code without proper sandboxing.\n\nit’s possible that you can use Deno sandboxing safely if you:\n\n- never use more dangerous permissions like `--allow-run` , even with`=cmd` ,\n- that includes `--allow-env` , even`--allow-env=VAR` , for setting environment variables is memory unsafe and can affect libc functions,\n- preferrably run with `--no-prompt` so your terminal can’t be tricked,\n- are careful about symlinks in directories you `--allow-{read,write}` to,\n- are not concerned with resource exhaustion: there’re zero permissions required to burn CPU or allocate memory.\n\nin particular, you may be safe if you’re running untrusted code with no permissions at all in a non-interactive context and use some other mechanism to control resource consumption.\n\nI still don’t think you *should* do it. this path is riddled with footguns because you’re\nexecuting untrusted code in a fully-privileged process, and the moment you need *some* OS interactions\nyou’re no longer running code “with no permissions at all”. you should not try to figure out which\nstdlib APIs can lead to a sandbox escape when combined. you should just use a proper sandbox.\n\nI’m not a fan of Deno’s security model.\n\n## so what do we do?\n\njust `bwrap` untrusted shit.\n\nalso, please: don’t harass Deno developers. we have a technical disagreement, but no technical disagreement was ever solved by harassment. this post is explicitly not an invitation to do it. I’ve already explained my point of view to them, they disagreed, and that’s okay. you don’t need to reiterate it, it won’t help anybody.</code></pre>","headings":[{"level":1,"text":"I’m not a fan of Deno’s security model","id":"i-m-not-a-fan-of-deno-s-security-model"},{"level":2,"text":"wait, what’s Deno?","id":"wait-what-s-deno"}]}}