otto

If you want to see what a JS interpreter in Go would look like, you can look at https://pkg.go.dev/github.com/robertkrimen/otto and https://github.com/dop251/goja . Of course they aren't "ports", but I feel like having two fairly complete intepreters is probably enough to prove the point. Arguably even a "port" would require enough changes that it wouldn't really be a "port" anyhow. (The quickjs package in the sibling comment is the original compiled into C. It will probably have all the security quirks of the original as a result.)

I am using otto[0] (similar to goja) in the headless cms I maintain [1] in "actions" api [2]. So one can customize actions according to needs by writing JS. The JS is executed inside a transaction. Sort of a mini-lambda kind of api [0] https://github.com/robertkrimen/otto [1] https://github.com/daptin/daptin [2] https://daptin.github.io/docs/actions/actions/

I've been a pretty happy Otto[1] user for a number of years now. The article makes no comparisons seemingly? I don't think there's even a never. I find that pretty odd. I'm curious if there'd be any reason to switch. https://github.com/robertkrimen/otto

It really depends on who (which team) is doing it. I would almost surely give up before understanding what esbuild does and how, and what needs to be modified. (Because Go basically gives me the creeps.) So someone with a lot of Rust experience probably simply opts for the rewrite. That said, it seems folks on the Vite team decided to give this a try because of oxc_parser (a JS parser written in Rust), so probably it's not because of Rust-Go sentimentalism. // Though ... there's also otto[1] (a JS parser in Go) ... so who knows! :)) // And of course even more context here[2] and here[3] (this one is from Evan You) // [1] https://github.com/robertkrimen/otto [2] https://news.ycombinator.com/item?id=39641634 [3] https://news.ycombinator.com/item?id=39648399

Not the parent but there are several high quality native (meaning no CGO) Lua implementations for Go and it's a great choice if you want an embedded scripting language: https://github.com/yuin/gopher-lua https://github.com/Shopify/go-lua Unless you specifically need a JVM either of these will be a much more practical and mature choice for embedded scripting. Alternatively if you prefer JS then Otto is a good choice: https://github.com/robertkrimen/otto

Ummm, excuse me, but where the f&$k has this been hiding? I’ve been looking for ways to extend my go applications with scripting support. I started with Lua (worked ) then Python (worked but hacky) then javascript using otto [1]. However it lacks ES6 support so having pretty OOP js code is a non-starter. I would love to have Java as a runtime that can be executed from goroutines. [1] https://github.com/robertkrimen/otto

> why host other languages Here's an example: I recently finished building https://subzo.com.au which allows customizing and ordering 3D models. The way the model's cost, volume and other attributes are calculated needs to be done both on the frontend (for speed) and on the backend (to validate). Backend is in Go and we can't practically run Go in the browser. So instead, I wrote the calculation snippets in JavaScript (which runs natively in the browser) and ran them on the backend on a JavaScript VM library written in Go [1]. [1]: https://github.com/robertkrimen/otto

I had a similar problem that I solved with goquery and otto. You can use goquery to traverse the DOM and otto to execute the script fragment. Then just grab the data from otto's VM. Your scraping being slow and using Chrome might be a blessing in disguise though. If you aren't careful you can get detected as a bot and banned from the site. https://github.com/PuerkitoBio/goquery https://github.com/robertkrimen/otto

Plus Otto, a JavaScript interpreter written Go: https://github.com/robertkrimen/otto

You have different options: The first one is to use NodeJS as your front end server and Golang for your API. The second one is to use NodeJS with React as an internal micro service to returns the HTML content back to the Golang front end server. The last one is to use a JavaScript interpreter within Golang. Some developers are doing the same in Java. Check this project for this option: https://github.com/robertkrimen/otto Now the question is which one is good. As always it depends on what you're looking for. I would say the NodeJS micro service renderer would be my favorite as it keeps all the complex logic in Golang.

Go is a perfectly good language for many applications. Why would you want to write yet another language to transpile to Go? You might want to look at Otto, a JS interpreter in Go, https://github.com/robertkrimen/otto

I love this type of projects. Relevant: https://github.com/robertkrimen/otto (JavaScript interpreter in go) https://github.com/Shopify/go-lua Lua VM in go

there is already go project named otto: https://github.com/robertkrimen/otto

There's also otto, a JavaScript interpreter written in Go: https://github.com/robertkrimen/otto Here's an example Go app using otto for React server-side rendering: https://github.com/101loops/go-reactjs