Monaco Editor VS tauri

So lets say the project consists of two packages Lib and App in which Lib is a library and App is the frontend app which depends on Lib. Now I want to display a monaco powered code editor in App which has has access to all types of Lib. This means that I have to somehow read the *.d.ts file of Lib as a string to set it as "extra lib" for monaco.

You’ll see a Monaco Editor-powered change editor. The content incoming from the Git repo is on the left, while the current content in Vrite is on the right. You can make changes in the editor on the right - this will ultimately become the result content. Once you’re done, click Resolve. If there are no other conflicts, you should now be able to pull the latest changes.

By referencing the ProseMirror docs, forwarding the editor state back and forth, and adjusting the layout, I managed to integrate Monaco Editor — the web editor extracted from VS Code — together with Prettier (for code formatting) right into the Vrite Editor (I know, that’s a lot of editors in one place 😅).

Now, there’s still some work to be done here. Monaco editor doesn’t work well for mobile, and some “optional” features weren’t yet optimized (like link previews or comments).

mozes koristiti gotovi code editor library, https://codemirror.net/ https://microsoft.github.io/monaco-editor/

Codemirror & vue. Chances are if you're using a code editor in a web app it's either Microsoft's Monaco [0] or CodeMirror [1], which is maintained by Marijn Haverbeke

[0] https://github.com/microsoft/monaco-editor

https://github.com/microsoft/monaco-editor/issues/246

Highly recommend Tauri over Electron, if you are going to be using a web ui stack. Same kind of thing as Electron, just fresher so it's more streamlined (for now). It's Rust, but you can use extern libraries from most other languages, if you really need to.

https://tauri.app/

If you want to learn Svelte or Rust (Tauri) while building this project with us, send me an inbox!

I want to ship a web frontend embedded inside a Rust binary to end users, such as a desktop application. Projects like Tauri achieve embedding with code generation by writing Rust code that generates more Rust code. Why does Tauri choose to use code generation over less complicated solutions? Let’s take a look at what that solution might look like.

This isn't an electron alternative, though, right?

There's atleast https://wails.io/ for Go, and https://tauri.app/ for rust ofc.

For the longest time, building desktop apps was a daunting task to web developers. That is, until technologies like Electron made creating these apps more approachable to a wider audience. Today, we’ve got a wide array of native applications built with solutions like Electron, Tauri, Capacitor, and many more. While these are great solutions, sometimes configuration can be tricky and the applications we create can become somewhat bloated in terms of memory usage.

Isn't this what Tauri wants to achieve? At least it's on the roadmap I mean.

https://tauri.app/

Does anyone have any experience creating production apps with Tauri? Seems like a sane alternative to Electron, especially if they can target all major platforms and keep the promise of smaller footprints.

Agreed, the web stack should definitely help get some contributions. I might take a look too :-)

Tangential but have you considered something like https://tauri.app/ instead of Electron for the app? (One of my major concerns with Electron apps is that every app ships and runs its own copy of Chromium – Tauri mitigates that by using system web engine instead.)

DotNet core using webview 2 and something like react for the frontend.

Or you can look into https://tauri.app/

Mozilla used to work on it: https://github.com/mozilla/positron

Currently I'm guessing https://tauri.app/ would be the easiest way to get away from electron.

Custom titlebar in Nuxt and Tauri? Not to hard! I will use the code from the previous tutorial, but you can use it in any existing project without any problems. And like always, everything is on GitHub.