diff --git a/website/src/pages/changelog.md b/website/src/pages/changelog.md
index 529951d73..8e1353ef3 100644
--- a/website/src/pages/changelog.md
+++ b/website/src/pages/changelog.md
@@ -7,12 +7,104 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased]
+## [v2.0.0-beta.35] - 2022-04-27
+
+### Breaking Changes
+
+- When data was sent to the `EventsOn` callback, it was being sent as a slice of values,
+ instead of optional parameters to the method. `EventsOn` now works as expected, but you will need to update your code
+ if you
+ currently use this. [More information](https://github.com/wailsapp/wails/issues/1324)
+- The broken `bindings.js` and `bindings.d.ts` files have been replaced by a new JS/TS code generation system. More
+ details [here](https://wails.io/docs/howdoesitwork#calling-bound-go-methods)
+
+### Added
+
+- **New Templates**: Svelte, React, Vue, Preact, Lit and Vanilla templates, both JS and TS versions. `wails init -l` for
+ more info.
+- Default templates now powered by [Vite](https://vitejs.dev). This enables lightning fast reloads when you
+ use `wails dev`!
+- Add support for external frontend development servers. See `frontend:dev:serverUrl` in
+ the [project config](https://wails.io/docs/reference/project-config) - [@stffabi](https://github.com/stffabi)
+- [Fully configurable dark mode](https://wails.io/docs/reference/options#theme) for Windows.
+- Hugely improved [WailsJS generation](https://wails.io/docs/howdoesitwork#calling-bound-go-methods) (both Javascript
+ and Typescript)
+- Wails doctor now reports information about the wails installation - [@stffabi](https://github.com/stffabi)
+- Added docs for [code-signing](https://wails.io/docs/guides/signing)
+ and [NSIS installer](https://wails.io/docs/guides/windows-installer) - [@gardc](https://github.com/gardc)
+- Add support for `-trimpath` [build flag](https://wails.io/docs/reference/cli#build)
+- Add support for a default AssetsHandler - [@stffabi](https://github.com/stffabi)
+
+### Fixed
+
+- Improved mimetype detection for BOM marker and comments - [@napalu](https://github.com/napalu)
+- Remove duplicate mimetype entries - [@napalu](https://github.com/napalu)
+- Remove duplicate Typescript imports in generated definition files - [@adalessa](https://github.com/adalessa)
+- Add missing method declaration - [@adalessa](https://github.com/adalessa)
+- Fix Linux sigabrt on start - [@napalu](https://github.com/napalu)
+- Double Click event now works on elements with `data-wails-drag` attribute - [@jicg](https://github.com/jicg)
+- Suppress resizing during minimize of a frameless window - [@stffabi](https://github.com/stffabi)
+- Fixed TS/JS generation for Go methods with no returns
+- Fixed WailsJS being generated in project directory
+
+### Changed
+
+- Website docs are now versioned
+- Improved `runtime.Environment` call
+- Improve the close action for Mac
+- A bunch of dependabot security updates
+- Improved website content - [@misitebao](https://github.com/misitebao)
+- Upgrade issue template - [@misitebao](https://github.com/misitebao)
+- Convert documents that don't require version management to individual pages
+ - [@misitebao](https://github.com/misitebao)
+- Website now using Algolia search
+
+## [v2.0.0-beta.34] - 2022-03-26
+
+### Added
+
+- Add support for 'DomReady' callback on linux by [@napalu](https://github.com/napalu) in #1249
+- MacOS - Show extension by default by [@leaanthony](https://github.com/leaanthony) in #1228
+
+### Fixed
+
+- [v2, nsis] Seems like / as path separator works only for some directives in a cross platform way
+ by [@stffabi](https://github.com/stffabi) in #1227
+- import models on binding definition by [@adalessa](https://github.com/adalessa) in #1231
+- Use local search on website by [@leaanthony](https://github.com/leaanthony) in #1234
+- Ensure binary resources can be served by [@napalu](https://github.com/napalu) in #1240
+- Only retry loading assets when loading from disk by [@leaanthony](https://github.com/leaanthony) in #1241
+- [v2, windows] Fix maximised start state by [@stffabi](https://github.com/stffabi) in #1243
+- Ensure Linux IsFullScreen uses GDK_WINDOW_STATE_FULLSCREEN bitmask appropriately.
+ by [@ianmjones](https://github.com/ianmjones) in #1245
+- Fix memory leak in ExecJS for Mac by [@leaanthony](https://github.com/leaanthony) in #1230
+- Fix, or at least a workaround, for (#1232) by [@BillBuilt](https://github.com/BillBuilt) in #1247
+- [v2] Use os.Args[0] for self starting wails by [@stffabi](https://github.com/stffabi) in #1258
+- [v2, windows] Windows switch scheme: https -> http by @stefpap in #1255
+- Ensure Focus is regained by Webview2 when tabbing by [@leaanthony](https://github.com/leaanthony) in #1257
+- Try to focus window when Show() is called. by [@leaanthony](https://github.com/leaanthony) in #1212
+- Check system for user installed Linux dependencies by [@leaanthony](https://github.com/leaanthony) in #1180
+
+### Changed
+
+- feat(website): sync documents and add content by [@misitebao](https://github.com/misitebao) in #1215
+- refactor(cli): optimize default templates by [@misitebao](https://github.com/misitebao) in #1214
+- Run watcher after initial build by [@leaanthony](https://github.com/leaanthony) in #1216
+- Feature/docs update by [@leaanthony](https://github.com/leaanthony) in #1218
+- feat(website): optimize website and sync documents by [@misitebao](https://github.com/misitebao) in #1219
+- docs: sync documents by [@misitebao](https://github.com/misitebao) in #1224
+- Default index page by [@leaanthony](https://github.com/leaanthony) in #1229
+- Build added win32 compatibility by [@fengweiqiang](https://github.com/fengweiqiang) in #1238
+- docs: sync documents by [@misitebao](https://github.com/misitebao) in #1260
+
## [v2.0.0-beta.33] - 2022-03-05
### Added
-- NSIS Installer support for creating installers for Windows applications - Thanks [@stffabi](https://github.com/stffabi) π
-- New frontend:dev:watcher command to spin out 3rd party watchers when using wails dev - Thanks [@stffabi](https://github.com/stffabi)π
+- NSIS Installer support for creating installers for Windows applications -
+ Thanks [@stffabi](https://github.com/stffabi) π
+- New frontend:dev:watcher command to spin out 3rd party watchers when using wails dev -
+ Thanks [@stffabi](https://github.com/stffabi)π
- Remote templates now support version tags - Thanks [@misitebao](https://github.com/misitebao) π
### Fixed
diff --git a/website/static/img/vitejs.svg b/website/static/img/vitejs.svg
new file mode 100644
index 000000000..124b17651
--- /dev/null
+++ b/website/static/img/vitejs.svg
@@ -0,0 +1,23 @@
+
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/appendix/_category_.json b/website/versioned_docs/version-v2.0.0-beta.35/appendix/_category_.json
new file mode 100644
index 000000000..83af4ca28
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/appendix/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Appendix",
+ "position": 70
+}
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/_category_.json b/website/versioned_docs/version-v2.0.0-beta.35/community/_category_.json
new file mode 100644
index 000000000..524986e1e
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Community",
+ "position": 50
+}
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/links.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/links.mdx
new file mode 100644
index 000000000..d081cb9b3
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/links.mdx
@@ -0,0 +1,24 @@
+---
+sidebar_position: 2
+---
+
+# Links
+
+This page serves as a list for community related links. Please submit a PR (click `Edit this page` at the bottom)
+to submit links.
+
+## Awesome Wails
+
+The [definitive list](https://github.com/wailsapp/awesome-wails) of links related to Wails.
+
+## Support Channels
+
+- [Gophers Slack Channel](https://gophers.slack.com/messages/CJ4P9F7MZ/)
+- [Gophers Slack Channel Invite](https://invite.slack.golangbridge.org/)
+- [Github Issues](https://github.com/wailsapp/wails/issues)
+- [v2 Beta Discussion Board](https://github.com/wailsapp/wails/discussions/828)
+
+## Social Media
+
+- [Twitter](https://twitter.com/wailsapp)
+- [Wails Chinese Community QQ Group](https://qm.qq.com/cgi-bin/qm/qr?k=PmIURne5hFGNd7QWzW5qd6FV-INEjNJv&jump_from=webapi) - Group number: 1067173054
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/_category_.json b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/_category_.json
new file mode 100644
index 000000000..276e283b7
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Showcase",
+ "position": 1
+}
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/encrypteasy.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/encrypteasy.mdx
new file mode 100644
index 000000000..32833f349
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/encrypteasy.mdx
@@ -0,0 +1,9 @@
+# EncryptEasy
+
+
+
+
+
+**[EncryptEasy](https://www.encrypteasy.app) is a simple and easy to use PGP encryption tool, managing all your and your contacts keys. Encryption should be simple. Developed with Wails.**
+
+Encrypting messages using PGP is the industry standard. Everyone has a private and a public key. Your private key, well, needs to be kept private so only you can read messages. Your public key is distributed to anyone who wants to send you secret, encrypted messages. Managing keys, encrypting messages and decrypting messages should be a smooth experience. EncryptEasy is all about making it easy.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/filehound.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/filehound.mdx
new file mode 100644
index 000000000..ff9929640
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/filehound.mdx
@@ -0,0 +1,22 @@
+# FileHound Export Utility
+
+
+
+
+
+
+[FileHound Export Utility](https://www.filehound.co.uk/) FileHound is a cloud document management platform made for secure file retention, business process automation and SmartCapture capabilities.
+
+The FileHound Export Utility allows FileHound Administrators the ability to run a secure document and data extraction tasks for alternative back-up and recovery purposes. This application will download all documents and/or meta data saved in FileHound based on the filters you choose. The metadata will be exported in both JSON and XML formats.
+
+Backend built with:
+Go 1.15
+Wails 1.11.0
+go-sqlite3 1.14.6
+go-linq 3.2
+
+Frontend with:
+Vue 2.6.11
+Vuex 3.4.0
+Typescript
+Tailwind 1.9.6
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/mollywallet.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/mollywallet.mdx
new file mode 100644
index 000000000..24912f0ab
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/mollywallet.mdx
@@ -0,0 +1,8 @@
+# Molley Wallet
+
+
+
+
+
+[Molly Wallet](https://github.com/grvlle/constellation_wallet/) the official $DAG wallet of the Constellation Network. It'll let users interact with the Hypergraph Network in various ways, not limited to producing $DAG transactions.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/optimus.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/optimus.mdx
new file mode 100644
index 000000000..bb0b0d4a1
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/optimus.mdx
@@ -0,0 +1,8 @@
+# Optimus
+
+
+
+
+
+[Optimus](https://github.com/splode/optimus) is a desktop image optimization application. It supports conversion and compression between WebP, JPEG, and PNG image formats.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/portfall.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/portfall.mdx
new file mode 100644
index 000000000..792821349
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/portfall.mdx
@@ -0,0 +1,8 @@
+# Portfall
+
+
+
+
+
+[Portfall](https://github.com/rekon-oss/portfall) - A desktop k8s port-forwarding portal for easy access to all your cluster UIs
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/riftshare.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/riftshare.mdx
new file mode 100644
index 000000000..cbbbcdf48
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/riftshare.mdx
@@ -0,0 +1,18 @@
+# RiftShare
+
+
+
+
+
+Easy, Secure, and Free file sharing for everyone. Learn more at [Riftshare.app](https://riftshare.app)
+
+## Features
+
+* Easy secure file sharing between computers both in the local network and through the internet
+* Supports sending files or directories securely through the [magic wormhole protocol](https://magic-wormhole.readthedocs.io/en/latest/)
+* Compatible with all other apps using magic wormhole (magic-wormhole or wormhole-william CLI, wormhole-gui, etc.)
+* Automatic zipping of multiple selected files to send at once
+* Full animations, progress bar, and cancellation support for sending and receiving
+* Native OS File Selection
+* Open files in one click once received
+* Auto Update - don't worry about having the latest release!
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/surge.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/surge.mdx
new file mode 100644
index 000000000..bccc51c82
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/surge.mdx
@@ -0,0 +1,8 @@
+# Surge
+
+
+
+
+
+[Surge](https://surge.rule110.io/) is a p2p filesharing app designed to utilize blockchain technologies to enable 100% anonymous file transfers. Surge is end-to-end encrypted, decentralized and open source.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/wally.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/wally.mdx
new file mode 100644
index 000000000..2a0d14ab0
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/wally.mdx
@@ -0,0 +1,8 @@
+# Wally
+
+
+
+
+
+[Wally](https://ergodox-ez.com/pages/wally) is the official firmware flasher for [Ergodox](https://ergodox-ez.com/) keyboards. It looks great and is a fantastic example of what you can achieve with Wails: the ability to combine the power of Go and the rich graphical tools of the web development world.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/wombat.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/wombat.mdx
new file mode 100644
index 000000000..d806f8c92
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/wombat.mdx
@@ -0,0 +1,9 @@
+# Wombat
+
+
+
+
+
+
+[Wombat](https://github.com/rogchap/wombat) is a cross platform gRPC client.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/ytd.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/ytd.mdx
new file mode 100644
index 000000000..fe3c47912
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/showcase/ytd.mdx
@@ -0,0 +1,9 @@
+# Ytd
+
+
+
+
+
+
+[Ytd](https://github.com/marcio199226/ytd/tree/v2-wails) is an app for downloading tracks from youtube, creating offline playlists and share them with your friends, your friends will be able to playback your playlists or download them for offline listening, has an built-in player.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/community/templates.mdx b/website/versioned_docs/version-v2.0.0-beta.35/community/templates.mdx
new file mode 100644
index 000000000..076a6b041
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/community/templates.mdx
@@ -0,0 +1,47 @@
+---
+sidebar_position: 1
+---
+
+# Templates
+
+This page serves as a list for community supported templates. Please submit a PR (click `Edit this page` at the bottom)
+to include your templates. To build your own template, please see the [Templates](../guides/templates.mdx) guide.
+
+To use these templates, run `wails init -n "Your Project Name" -t [the link below[@version]]`
+
+If there is no version suffix, the main branch code template is used by default. If there is a version suffix, the code template corresponding to the tag of this version is used.
+
+Example: `wails init -n "Your Project Name" -t https://github.com/misitebao/wails-template-vue`
+
+:::warning Attention
+
+**The Wails project does not maintain, is not responsible nor liable for 3rd party templates!**
+
+If you are unsure about a template, inspect `package.json` and `wails.json` for what scripts are run and what packages are installed.
+
+:::
+
+## Vue
+
+- [wails-template-vue](https://github.com/misitebao/wails-template-vue) - A template using Vite,Vue and Vue-Router(Support both JavaScript and TypeScript)
+- [wails-vite-vue-ts](https://github.com/codydbentley/wails-vite-vue-ts) - Vue 3 TypeScript with Vite (and instructions to add features)
+- [wails-vite-vue-the-works](https://github.com/codydbentley/wails-vite-vue-the-works) - Vue 3 TypeScript with Vite, Vuex, Vue Router, Sass, and ESLint + Prettier
+
+## Angular
+
+- [wails-angular-template](https://github.com/TAINCER/wails-angular-template) - Angular with TypeScript, Sass, Hot-Reload, Code-Splitting and i18n
+
+## React
+
+- [wails-react-template](https://github.com/AlienRecall/wails-react-template) - A template using reactjs
+- [wails-react-template](https://github.com/flin7/wails-react-template) - A minimal template for React that supports live development
+
+## Svelte
+
+- [wails-svelte-template](https://github.com/raitonoberu/wails-svelte-template) - A template using Svelte
+- [wails-vite-svelte-template](https://github.com/BillBuilt/wails-vite-svelte-template) - A template using Svelte and Vite
+- [wails-vite-svelte-tailwind-template](https://github.com/BillBuilt/wails-vite-svelte-tailwind-template) - A template using Svelte and Vite with TailwindCSS v3
+
+## Elm
+
+- [wails-elm-template](https://github.com/benjamin-thomas/wails-elm-template) - Develop your GUI app with functional programming and a **snappy** hot-reload setup :tada: :rocket:
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/_category_.json b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/_category_.json
new file mode 100644
index 000000000..597b920df
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Getting Started",
+ "position": 10
+}
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/building.mdx b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/building.mdx
new file mode 100644
index 000000000..741659e81
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/building.mdx
@@ -0,0 +1,20 @@
+---
+sidebar_position: 6
+---
+
+# Compiling your Project
+
+From the project directory, run `wails build`.
+This will compile your project and save the production-ready binary in the `build/bin` directory.
+
+If you run the binary, you should see the default application:
+
+
+
+
+
+
+
+For more details on compilation options, please refer to the [CLI Reference](../reference/cli.mdx#build).
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/development.mdx b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/development.mdx
new file mode 100644
index 000000000..323e90ba9
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/development.mdx
@@ -0,0 +1,16 @@
+---
+sidebar_position: 5
+---
+
+# Developing your Application
+
+You can run your application in development mode by running `wails dev` from your project directory. This will do the following things:
+
+ - Build your application and run it
+ - Bind your Go code to the frontend so it can be called from Javascript
+ - Using the power of [vite](https://vitejs.dev/), will watch for modifications in your Go files and rebuild/re-run on change
+ - Sets up a [webserver](http://localhost:34115) that will serve your application over a browser. This allows you to use your favourite browser extensions. You can even call your Go code from the console
+
+To get started, run `wails dev` in the project directory. More information on this can be found [here](../reference/cli.mdx#dev).
+
+Coming soon: Tutorial
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/firstproject.mdx b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/firstproject.mdx
new file mode 100644
index 000000000..55413fffb
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/firstproject.mdx
@@ -0,0 +1,126 @@
+---
+sidebar_position: 2
+---
+
+# Creating a Project
+
+## Project Generation
+
+Now that the CLI is installed, you can generate a new project by using the `wails init` command.
+
+Pick your favourite framework:
+
+
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+
+
+ Generate a Svelte project using Javascript with:
+
+ wails init -n myproject -t svelte
+
+ If you would rather use Typescript:
+
+ wails init -n myproject -t svelte-ts
+
+
+ Generate a React project using Javascript with:
+
+ wails init -n myproject -t react
+
+ If you would rather use Typescript:
+
+ wails init -n myproject -t react-ts
+
+
+ Generate a Vue project using Javascript with:
+
+ wails init -n myproject -t vue
+
+ If you would rather use Typescript:
+
+ wails init -n myproject -t vue-ts
+
+
+ Generate a Preact project using Javascript with:
+
+ wails init -n myproject -t preact
+
+ If you would rather use Typescript:
+
+ wails init -n myproject -t preact-ts
+
+
+ Generate a Lit project using Javascript with:
+
+ wails init -n myproject -t lit
+
+ If you would rather use Typescript:
+
+ wails init -n myproject -t lit-ts
+
+
+ Generate a Vanilla project using Javascript with:
+
+ wails init -n myproject -t vanilla
+
+ If you would rather use Typescript:
+
+ wails init -n myproject -t vanilla-ts
+
+
+
+
+
+There are also [community templates](../community/templates.mdx) available that offer different capabilities and frameworks.
+
+To see the other options available, you can run `wails init -help`.
+More details can be found in the [CLI Reference](../reference/cli.mdx#init).
+
+## Project Layout
+
+Wails projects have the following layout:
+
+```
+.
+βββ build/
+β βββ appicon.png
+β βββ darwin/
+β βββ windows/
+βββ frontend/
+βββ go.mod
+βββ go.sum
+βββ main.go
+βββ wails.json
+```
+
+### Project structure rundown
+
+- `/main.go` - The main application
+- `/frontend/` - Frontend project files
+- `/build/` - Project build directory
+- `/build/appicon.png` - The application icon
+- `/build/darwin/` - Mac specific project files
+- `/build/windows/` - Windows specific project files
+- `/wails.json` - The project configuration
+- `/go.mod` - Go module file
+- `/go.sum` - Go module checksum file
+
+The `frontend` directory has nothing specific to Wails and can be any frontend project of your choosing.
+
+The `build` directory is used during the build process. These files may be updated to customise your builds. If
+files are removed from the build directory, default versions will be regenerated.
+
+The default module name in `go.mod` is "changeme". You should change this to something more appropriate.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/installation.mdx b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/installation.mdx
new file mode 100644
index 000000000..cee8556ff
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/gettingstarted/installation.mdx
@@ -0,0 +1,81 @@
+---
+sidebar_position: 1
+---
+
+# Installation
+
+## Supported Platforms
+
+- Windows 10/11 AMD64/ARM64
+- MacOS 10.13+ AMD64
+- MacOS 11.0+ ARM64
+- Linux AMD64/ARM64
+
+## Dependencies
+
+Wails has a number of common dependencies that are required before installation:
+
+- Go 1.17+
+- NPM (Node 15+)
+
+### Go
+
+Download Go from the [Go Downloads Page](https://golang.org/dl/).
+
+Ensure that you follow the official [Go installation instructions](https://golang.org/doc/install.mdx#install). You will also need to ensure that your `PATH` environment variable also includes the path to your `~/go/bin` directory. Restart your terminal and do the following checks:
+
+- Check Go is installed correctly: `go version`
+- Check "~/go/bin" is in your PATH variable: `echo $PATH | grep go/bin`
+
+### NPM
+
+Download NPM from the [Node Downloads Page](https://nodejs.org/en/download/). It is best to use the latest release as that is what we generally test against.
+
+Run `npm --version` to verify.
+
+## Platform Specific Dependencies
+
+You will also need to install platform specific dependencies:
+
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+
+
+ Wails requires that the xcode command line tools are installed. This can be done by running:
+
+ xcode-select --install
+
+
+ Wails requires that the WebView2{" "}
+ runtime is installed. Some Windows installations will already have this installed. You can check using the{" "}
+ wails doctor command (see below).
+
+ Linux required the standard gcc build tools
+ plus libgtk3 and libwebkit.
+ Rather than list a ton of commands for different distros, Wails can try to determine
+ what the installation commands are for your specific distribution. Run wails doctor after installation
+ to be shown how to install the dependencies.
+ If your distro/package manager is not supported, please consult the Add
+ Linux Distro guide.
+
+
+## Optional Dependencies
+
+- [UPX](https://upx.github.io/) for compressing your applications.
+
+## Installing Wails
+
+Run `go install github.com/wailsapp/wails/v2/cmd/wails@latest` to install the Wails CLI.
+
+## System Check
+
+Running `wails doctor` will check if you have the correct dependencies installed. If not, it will advise on what is missing and help on how to rectify any problems.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/_category_.json b/website/versioned_docs/version-v2.0.0-beta.35/guides/_category_.json
new file mode 100644
index 000000000..5935dad93
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Guides",
+ "position": 50
+}
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/application-development.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/application-development.mdx
new file mode 100644
index 000000000..b45f252d4
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/application-development.mdx
@@ -0,0 +1,196 @@
+# Application Development
+
+There are no hard and fast rules for developing applications with Wails, but there are some basic guidelines.
+
+## Application Setup
+
+The pattern used by the default templates are that `main.go` is used for configuring and running the application, whilst
+`app.go` is used for defining the application logic.
+
+The `app.go` file will define a struct that has 2 methods which act as hooks into the main application:
+
+```go title="app.go"
+type App struct {
+ ctx context.Context
+}
+
+func NewApp() *App {
+ return &App{}
+}
+
+func (a *App) startup(ctx context.Context) {
+ a.ctx = ctx
+}
+
+func (a *App) shutdown(ctx context.Context) {
+}
+```
+
+- The startup method is called as soon as Wails allocates the resources it needs and is a good place for creating resources,
+setting up event listeners and anything else the application needs at startup.
+It is given a `context.Context` which is usually saved in a struct field. This context is needed for calling the
+[runtime](../reference/runtime/intro.mdx). If this method returns an error, the application will terminate.
+In dev mode, the error will be output to the console.
+
+- The shutdown method will be called by Wails right at the end of the shutdown process. This is a good place to deallocate
+memory and perform any shutdown tasks.
+
+The `main.go` file generally consists of a single call to `wails.Run()`, which accepts the application configuration.
+The pattern used by the templates is that before the call to `wails.Run()`, an instance of the struct we defined in
+`app.go` is created and saved in a variable called `app`. This configuration is where we add our callbacks:
+
+```go {3,9,10} title="main.go"
+func main() {
+
+ app := NewApp()
+
+ err := wails.Run(&options.App{
+ Title: "My App",
+ Width: 800,
+ Height: 600,
+ OnStartup: app.startup,
+ OnShutdown: app.shutdown,
+ })
+ if err != nil {
+ log.Fatal(err)
+ }
+}
+
+```
+
+More information on application lifecycle hooks can be found [here](../howdoesitwork.mdx#application-lifecycle-callbacks).
+
+## Binding Methods
+
+It is likely that you will want to call Go methods from the frontend. This is normally done by adding public methods to
+the already defined struct in `app.go`:
+
+```go {16-18} title="app.go"
+type App struct {
+ ctx context.Context
+}
+
+func NewApp() *App {
+ return &App{}
+}
+
+func (a *App) startup(ctx context.Context) {
+ a.ctx = ctx
+}
+
+func (a *App) shutdown(ctx context.Context) {
+}
+
+func (a *App) Greet(name string) string {
+ return fmt.Printf("Hello %s!", name)
+}
+```
+
+In the main application configuration, the `Bind` key is where we can tell Wails what we want to bind:
+
+```go {11-13} title="main.go"
+func main() {
+
+ app := NewApp()
+
+ err := wails.Run(&options.App{
+ Title: "My App",
+ Width: 800,
+ Height: 600,
+ OnStartup: app.startup,
+ OnShutdown: app.shutdown,
+ Bind: []interface{}{
+ app,
+ },
+ })
+ if err != nil {
+ log.Fatal(err)
+ }
+}
+
+```
+
+This will bind all public methods in our `App` struct (it will never bind the startup and shutdown methods).
+
+More information on Binding can be found [here](../howdoesitwork.mdx#method-binding).
+
+## Application Menu
+
+Wails supports adding a menu to your application. This is done by passing a [Menu](../reference/menus.mdx#menu) struct
+to application config. It's common to use a method that returns a Menu, and even more common for that to be a method on
+the `App` struct used for the lifecycle hooks.
+
+```go {11} title="main.go"
+func main() {
+
+ app := NewApp()
+
+ err := wails.Run(&options.App{
+ Title: "My App",
+ Width: 800,
+ Height: 600,
+ OnStartup: app.startup,
+ OnShutdown: app.shutdown,
+ Menu: app.menu(),
+ Bind: []interface{}{
+ app,
+ },
+ })
+ if err != nil {
+ log.Fatal(err)
+ }
+}
+
+```
+
+## Assets
+
+The great thing about the way Wails v2 handles assets is that it doesn't! The only thing you need to give Wails is an
+`embed.FS`. How you get to that is entirely up to you. You can use vanilla html/css/js files like the vanilla template.
+You could have some complicated build system, it doesn't matter.
+
+When `wails build` is run, it will check the `wails.json` project file at the project root. There are 2 keys in the
+project file that are read:
+
+- "frontend:install"
+- "frontend:build"
+
+The first, if given, will be executed in the `frontend` directory to install the node modules.
+The second, if given, will be executed in the `frontend` directory to build the frontend project.
+
+If these 2 keys aren't given, then Wails does absolutely nothing with the frontend. It is only expecting that `embed.FS`.
+
+### AssetsHandler
+
+A Wails v2 app can optionally define a `http.Handler` in the `options.App`, which allows hooking into the AssetServer to
+create files on the fly or process POST/PUT requests.
+GET requests are always first handled by the `assets` FS. If the FS doesn't find the requested file the request will be
+forwarded to the `http.Handler` for serving. Any requests other than GET will be directly processed by the `AssetsHandler`
+if specified.
+It's also possible to only use the `AssetsHandler` by specifiy `nil` as the `Assets` option.
+
+## Built in Dev Server
+
+Running `wails dev` will start the built in dev server which will start a file watcher in your project directory. By
+default, if any file changes, wails checks if it was an application file (default: `.go`, configurable with `-e` flag).
+If it was, then it will rebuild your application and relaunch it. If the changed file was in the assets,
+it will issue a reload after a short amount of time.
+
+The dev server uses a technique called "debouncing" which means it doesn't reload straight away,
+as there may be multiple files changed in a short amount of time. When a trigger occurs, it waits for a set amount of time
+before issuing a reload. If another trigger happens, it resets to the wait time again. By default this value is `100ms`.
+If this value doesn't work for your project, it can be configured using the `-debounce` flag. If used, this value will
+be saved to your project config and become the default.
+
+## External Dev Server
+
+Some frameworks come with their own live-reloading server, however they will not be able to take advantage of the Wails
+Go bindings. In this scenario, it is best to run a watcher script that rebuilds the project into the build directory, which
+Wails will be watching. For an example, see the default svelte template that uses [rollup](https://rollupjs.org/guide/en/).
+For [create-react-app](https://create-react-app.dev/), it's possible to use
+[this script](https://gist.github.com/int128/e0cdec598c5b3db728ff35758abdbafd) to achieve a similar result.
+
+## Go Module
+
+The default Wails templates generate a `go.mod` file that contains the module name "changeme". You should change this
+to something more appropriate after project generation.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/bleeding-edge.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/bleeding-edge.mdx
new file mode 100644
index 000000000..a44a155de
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/bleeding-edge.mdx
@@ -0,0 +1,53 @@
+# Bleeding Edge
+
+## Overview
+
+Wails is in constant development and new releases are regularly "tagged". This usually happens when all the newer code
+on `master` has been tested and confirmed working. If you need a bugfix or feature that has not yet made it to a release,
+it's possible to use the latest "bleeding edge" version using the following steps:
+
+- `git clone https://github.com/wailsapp/wails`
+- `cd wails/v2/cmd/wails`
+- `go install`
+
+NOTE: The directory that you cloned the project into will now be called "clonedir".
+
+The Wails CLI will now be at the very latest version. To update projects to use the latest version, update the project's
+`go.mod` and ensure the following line is at the bottom of the file:
+
+`replace github.com/wailsapp/wails/v2 => `
+
+Example:
+
+On Windows:
+`replace github.com/wailsapp/wails/v2 => C:\Users\leaan\Documents\wails-v2-beta\wails\v2`
+
+On 'nix:
+`replace github.com/wailsapp/wails/v2 => /home/me/projects/wails/v2`
+
+To revert back to a stable version, run:
+
+`go install github.com/wailsapp/wails/v2/cmd/wails@latest`
+
+## Testing a Branch
+
+If you want to test a branch, follow the instructions above, but ensure you switch the branch you want to test before installing:
+
+- `git clone https://github.com/wailsapp/wails`
+- `cd wails`
+- `git checkout -b branch-to-test --track origin/branch-to-test`
+- `cd v2/cmd/wails`
+- `go install`
+
+## Testing a PR
+
+If you want to test a PR, follow the instructions above, but ensure you fetch the PR and switch the branch before installing.
+Please replace `[IDofThePR]` with the ID of the PR shown on github.com:
+
+- `git clone https://github.com/wailsapp/wails`
+- `cd wails`
+- `git fetch -u origin pull/[IDofThePR]/head:test/pr-[IDofThePR]`
+- `git checkout test/pr-[IDofThePR]`
+- `git reset --hard HEAD`
+- `cd v2/cmd/wails`
+- `go install`
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/developing-wails.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/developing-wails.mdx
new file mode 100644
index 000000000..5443d6681
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/developing-wails.mdx
@@ -0,0 +1,38 @@
+# Contributing
+
+This page is a guide on how to contribute to the Wails project.
+
+First, a word of warning: Wails v2 has been through a number of iterations and pivots. There is a lot of code that
+is either on hold or deprecated. Reading the whole project and trying to understand it may be confusing. This document
+aims to focus on what is current and how to understand that.
+
+## Bugs
+
+For raising bugs, please open a ticket on GitHub and give it the \[v2\] label. Include the output of `wails doctor`
+in the ticket to help us understand your environment.
+
+For fixing bugs, please comment on a ticket that you'd like to take it on and we will put a label on the ticket.
+It is best to use Windows as it is done in pure Go, making debugging much easier.
+
+## Features
+
+To request a new feature, raise a ticket so that it may be discussed. The ticket should be given the
+"Feature Request" label. These will be discussed and if selected for development will be given the label
+"Ready for Development".
+
+To implement a new feature, raise a ticket as above or select a ticket with the "Ready for Development" label.
+
+When raising a PR, be mindful to state what platforms the PR has been tested on. Any new feature will not be accepted unless it works
+on all platforms (if it can).
+
+:::warning What not to do
+
+PRs for features with no tickets aren't helpful as there's no context to the PR and it will not be prioritised.
+
+:::
+
+## Documentation
+
+Contributing to the documentation is easy by clicking on the "Edit this page" link on any of the pages. Documentation
+updates can be done ad-hoc, without a ticket.
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/frameless.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/frameless.mdx
new file mode 100644
index 000000000..c98aef3fd
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/frameless.mdx
@@ -0,0 +1,34 @@
+# Frameless Applications
+
+Wails supports applications with no frame. This can be achieved by using the [frameless](../reference/options.mdx#frameless)
+field in [Application Options](../reference/options.mdx#application-options).
+
+Wails offers a simple solution for dragging the window: Any HTML element that has the attribute "data-wails-drag" will
+act as a "drag handle". This property applies to all nested elements. If you need to indicate that a nested element
+should not drag, then use the attribute 'data-wails-no-drag' on that element.
+
+The default vanilla template uses this, even though it is not frameless. The whole `body` element is tagged as draggable.
+The `
` is tagged as being not draggable.
+
+```html
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+:::info Fullscreen
+If you allow your application to go fullscreen, this drag functionality will be disabled.
+:::
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/frontend.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/frontend.mdx
new file mode 100644
index 000000000..2ace49c4e
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/frontend.mdx
@@ -0,0 +1,76 @@
+# Frontend
+
+## Script Injection
+
+When Wails serves your `index.html`, by default, it will inject 2 script entries into the `` tag to load `/wails/bindings.js`
+and `/wails/runtime.js`. These files install the bindings and runtime respectively.
+
+The code below shows where these are injected by default:
+
+```html
+
+
+ injection example
+
+
+
+
+
+
+
+
Please enter your name below π
+
+
+
+
+
+
+
+
+
+```
+
+### Overriding Default Script Injection
+
+To provide more flexibility to developers, there is a meta tag that may be used to customise this behaviour:
+
+```html
+
+```
+
+The options are as follows:
+
+| Value | Description |
+| -------------------- | ------------------------------------------------- |
+| noautoinjectruntime | Disable the autoinjection of `/wails/runtime.js` |
+| noautoinjectipc | Disable the autoinjection of `/wails/ipc.js` |
+| noautoinject | Disable all autoinjection of scripts |
+
+Multiple options may be used provided they are comma seperated.
+
+This code is perfectly valid and operates the same as the autoinjection version:
+
+```html
+
+
+
+ injection example
+
+
+
+
+
+
+
Please enter your name below π
+
+
+
+
+
+
+
+
+
+
+
+```
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/ides.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/ides.mdx
new file mode 100644
index 000000000..14adde0d0
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/ides.mdx
@@ -0,0 +1,114 @@
+# IDEs
+
+Wails aims to provide a great development experience. To that aim, we now support generating IDE specific configuration
+to provide smoother project setup.
+
+Currently, we support [Visual Studio Code](https://code.visualstudio.com/) but aim to support other IDEs such as Goland.
+
+## Visual Studio Code
+
+
+
+
+
+When generating a project using the `-ide vscode` flags, IDE files will be created alongside the other project files.
+These files are placed into the `.vscode` directory and provide the correct configuration for debugging your application.
+
+The 2 files generated are `tasks.json` and `launch.json`. Below are the files generated for the default vanilla project:
+
+```json title="tasks.json"
+{
+ "version": "2.0.0",
+ "tasks": [
+ {
+ "label": "build",
+ "type": "shell",
+ "options": {
+ "cwd": "${workspaceFolder}"
+ },
+ "command": "go",
+ "args": ["build", "-tags", "dev", "-gcflags", "all=-N -l", "-o", "build/bin/myproject.exe"]
+ },
+ ]
+}
+```
+
+```json title="launch.json"
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "Wails: Debug myproject",
+ "type": "go",
+ "request": "launch",
+ "mode": "exec",
+ "program": "${workspaceFolder}/build/bin/myproject.exe",
+ "preLaunchTask": "build",
+ "cwd": "${workspaceFolder}",
+ "env": {}
+ },
+ ]
+}
+```
+
+### Configuring the install and build steps
+
+The `tasks.json` file is simple for the default project as there is no `npm install` or `npm run build` step needed.
+For projects that have a frontend build step, such as the svelte template, we would need to edit `tasks.json` to
+add the install and build steps:
+
+```json title="tasks.json"
+{
+ "version": "2.0.0",
+ "tasks": [
+ {
+ "label": "npm install",
+ "type": "npm",
+ "script": "install",
+ "options": {
+ "cwd": "${workspaceFolder}/frontend"
+ },
+ "presentation": {
+ "clear": true,
+ "panel": "shared",
+ "showReuseMessage": false
+ },
+ "problemMatcher": []
+ },
+ {
+ "label": "npm run build",
+ "type": "npm",
+ "script": "build",
+ "options": {
+ "cwd": "${workspaceFolder}/frontend"
+ },
+ "presentation": {
+ "clear": true,
+ "panel": "shared",
+ "showReuseMessage": false
+ },
+ "problemMatcher": []
+ },
+ {
+ "label": "build",
+ "type": "shell",
+ "options": {
+ "cwd": "${workspaceFolder}"
+ },
+ "command": "go",
+ "args": ["build", "-tags", "dev", "-gcflags", "all=-N -l", "-o", "build/bin/vscode.exe"],
+ "dependsOn":[
+ "npm install",
+ "npm run build"
+ ]
+
+ },
+ ]
+}
+```
+
+:::info Future Enhancement
+
+In the future, we hope to generate a `tasks.json` that includes the install and build steps automatically.
+
+:::
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/linux-distro-support.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/linux-distro-support.mdx
new file mode 100644
index 000000000..fedbc9ed6
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/linux-distro-support.mdx
@@ -0,0 +1,106 @@
+# Linux Distro Support
+
+## Overview
+
+Wails offers Linux support but providing installation instructions for all available distributions is an impossible task.
+Instead, Wails tries to determine if the packages you need to develop applications are available via your system's package
+manager. Currently, we support the following package managers:
+
+- apt
+- dnf
+- emerge
+- eopkg
+- pacman
+- zypper
+
+## Adding package names
+
+There may be circumstances where your distro uses one of the supported package managers but the package name
+is different. For example, you may use an Ubuntu derivative, but the package name for gtk may be different. Wails
+attempts to find the correct package by iterating through a list of package names.
+The list of packages are stored in the packagemanager specific file in the `v2/internal/system/packagemanager`
+directory. In our example, this would be `v2/internal/system/packagemanager/apt.go`.
+
+In this file, the list of packages are defined by the `Packages()` method:
+
+```go
+func (a *Apt) Packages() packagemap {
+ return packagemap{
+ "libgtk-3": []*Package{
+ {Name: "libgtk-3-dev", SystemPackage: true, Library: true},
+ },
+ "libwebkit": []*Package{
+ {Name: "libwebkit2gtk-4.0-dev", SystemPackage: true, Library: true},
+ },
+ "gcc": []*Package{
+ {Name: "build-essential", SystemPackage: true},
+ },
+ "pkg-config": []*Package{
+ {Name: "pkg-config", SystemPackage: true},
+ },
+ "npm": []*Package{
+ {Name: "npm", SystemPackage: true},
+ },
+ "docker": []*Package{
+ {Name: "docker.io", SystemPackage: true, Optional: true},
+ },
+ }
+}
+```
+
+Let's assume that in our linux distro, `libgtk-3` is packaged under the name `lib-gtk3-dev`.
+We could add support for this by adding the following line:
+
+```go {5}
+func (a *Apt) Packages() packagemap {
+ return packagemap{
+ "libgtk-3": []*Package{
+ {Name: "libgtk-3-dev", SystemPackage: true, Library: true},
+ {Name: "lib-gtk3-dev", SystemPackage: true, Library: true},
+ },
+ "libwebkit": []*Package{
+ {Name: "libwebkit2gtk-4.0-dev", SystemPackage: true, Library: true},
+ },
+ "gcc": []*Package{
+ {Name: "build-essential", SystemPackage: true},
+ },
+ "pkg-config": []*Package{
+ {Name: "pkg-config", SystemPackage: true},
+ },
+ "npm": []*Package{
+ {Name: "npm", SystemPackage: true},
+ },
+ "docker": []*Package{
+ {Name: "docker.io", SystemPackage: true, Optional: true},
+ },
+ }
+}
+```
+
+## Adding new package managers
+
+To add a new package manager, perform the following steps:
+
+- Create a new file in `v2/internal/system/packagemanager` called `.go`, where `` is the name of the package manager.
+- Define a struct that conforms to the package manager interface defined in `pm.go`:
+
+```go
+type PackageManager interface {
+ Name() string
+ Packages() packagemap
+ PackageInstalled(*Package) (bool, error)
+ PackageAvailable(*Package) (bool, error)
+ InstallCommand(*Package) string
+}
+```
+- `Name()` should return the name of the package manager
+- `Packages()` should return a `packagemap`, that provides candidate filenames for dependencies
+- `PackageInstalled()` should return `true` if the given package is installed
+- `PackageAvailable()` should return `true` if the given package is not installed but available for installation
+- `InstallCommand()` should return the exact command to install the given package name
+
+Take a look at the other package managers code to get an idea how this works.
+
+:::info Remember
+If you add support for a new package manager, don't forget to also update this page!
+:::
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/manual-builds.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/manual-builds.mdx
new file mode 100644
index 000000000..4594e527a
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/manual-builds.mdx
@@ -0,0 +1,98 @@
+# Manual Builds
+
+The Wails CLI does a lot of heavy lifting for the project, but sometimes it's desirable to manually build your project.
+This document will discuss the different operations the CLI does and how this may be achieved in different ways.
+
+## Build Process
+
+When either `wails build` or `wails dev` are used, the Wails CLI performs a common build process:
+
+ - Install frontend dependencies
+ - Build frontend project
+ - Generate build assets
+ - Compile application
+ - [optional] Compress application
+
+### Install frontend dependencies
+
+#### CLI Steps
+
+- If the `-s` flag is given, this step is skipped
+- Checks `wails.json` to see if there is an install command in the key `frontend:install`
+- If there isn't, it skips this step
+- If there is, it checks if `package.json` exists in the frontend directory. If it doesn't exist, it skips this step
+- An MD5 sum is generated from the `package.json` file contents
+- It checks for the existence of `package.json.md5` and if it exists, will compare the contents of it (an MD5 sum)
+with the one generated to see if the contents have changed. If they are the same, this step is skipped
+- If `package.json.md5` does not exist, it creates it using the generated MD5 sum
+- If a build is now required, or `node_modules` does not exist, or the `-f` flag is given, the install command is
+executed in the frontend directory
+
+#### Manual Steps
+
+This step could be done from the command line or a script with `npm install`.
+
+### Build frontend project
+
+#### Wails CLI
+
+- If the `-s` flag is given, this step is skipped
+- Checks `wails.json` to see if there is a build command in the key `frontend:build`
+- If there isn't, it skips this step
+- If there is, it is executed in the frontend directory
+
+#### Manual Steps
+
+This step could be done from the command line or a script with `npm run build` or whatever the frontend build script is.
+
+### Generate assets
+
+#### Wails CLI
+
+- If `-nopackage` flag is set, this stage is skipped
+- If the `build/appicon.png` file does not exist, a default one is created
+- For Windows, see [Bundling for Windows](#windows)
+- If `build/windows/icon.ico` does not exist, it will create it from the `build/appicon.png` image.
+
+##### Windows
+
+- If `build/windows/icon.ico` does not exist, it will create it from `build/appicon.png` using icon sizes of 256, 128, 64, 48, 32 and 16. This is done using [winicon](https://github.com/leaanthony/winicon).
+- If the `build/windows/.manifest` file does not exist, it creates it from a default version.
+- Compiles the application as a production build (above)
+- Uses [winres](https://github.com/tc-hib/winres) to bundle the icon and manifest into a `.syso` file ready for linking.
+
+#### Manual Steps
+
+- Create `icon.ico` using the [winicon](https://github.com/leaanthony/winicon) CLI tool (or any other tool).
+- Create / Update a `.manifest` file for your application
+- Use the [winres CLI](https://github.com/tc-hib/go-winres) to generate a `.syso` file.
+
+### Compile application
+
+#### Wails CLI
+
+- If the `-clean` flag is provided, the `build` directory is deleted and recreated
+- For `wails dev`, the following default Go flags are used: `-tags dev -gcflags "all=-N -l"`
+- For `wails build`, the following default Go flags are used: `-tags desktop,production -ldflags "-w -s"`
+- On Windows, `-ldflags "-w -h -H windowsgui"`
+- Additional tags passed to the CLI using `-tags` are added to the defaults
+- Additional ldflags passed to the CLI using `-ldflags` are added to the defaults
+- The `-o` flag is passed through
+- The Go compiler specified by `-compiler` will be used for compilation
+
+#### Manual steps
+
+- For dev build, the minimum command would be: `go build -tags dev -gcflags "all=-N -l"`
+- For production build, the minimum command would be: `go build -tags desktop,production -ldflags "-w -s -H windowsgui"`
+- Ensure that you compile in the same directory as the `.syso` file
+
+### Compress application
+
+#### Wails CLI
+
+- If the `-upx` flag has been given, the `upx` program will be run to compress the application with the default settings
+- If `-upxflags` is also passed, these flags are used instead of the default ones
+
+#### Manual steps
+
+- Run `upx [flags]` manually to compress the application.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/migrating.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/migrating.mdx
new file mode 100644
index 000000000..c391596a8
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/migrating.mdx
@@ -0,0 +1,207 @@
+# Migrating from v1
+
+## Overview
+
+Wails v2 is a significant change from v1. This document aims to highlight the changes and the steps in migrating an existing project.
+
+### Creating the Application
+
+In v1, the main application is created using `wails.CreateApp`, bindings are added with `app.Bind`, then the
+application is run using `app.Run()`.
+
+Example:
+
+```go title="v1"
+ app := wails.CreateApp(&wails.AppConfig{
+ Title: "MyApp",
+ Width: 1024,
+ Height: 768,
+ JS: js,
+ CSS: css,
+ Colour: "#131313",
+ })
+ app.Bind(basic)
+ app.Run()
+```
+
+In v2, there is just a single method, `wails.Run()`, that accepts [application options](../reference/options.mdx#application-options).
+
+```go title="v2"
+ err := wails.Run(&options.App{
+ Title: "MyApp",
+ Width: 800,
+ Height: 600,
+ Assets: assets,
+ Bind: []interface{}{
+ basic,
+ },
+ })
+```
+
+### Binding
+
+In v1, it was possible to bind both arbitrary functions and structs. In v2, this has been simplified to only binding structs.
+The struct instances that were previously passed to the `Bind()` method in v1, are now specified in the `Bind` field of
+the [application options](../reference/options.mdx#application-options):
+
+```go title="v1"
+ app := wails.CreateApp(/* options */)
+ app.Bind(basic)
+```
+
+```go title="v2"
+ err := wails.Run(&options.App{
+ /* other options */
+ Bind: []interface{}{
+ basic,
+ },
+ })
+```
+
+In v1, bound methods were available to the frontend at `window.backend`. This has changed to `window.go`.``
+
+### Application Lifecycle
+
+In v1, there were 2 special methods in a bound struct: `WailsInit()` and `WailsShutdown()`. These have
+been replaced with 3 lifecycle hooks as part of the [application options](../reference/options.mdx#application-options):
+
+- [OnStartup](../reference/options.mdx#onstartup)
+- [OnShutdown](../reference/options.mdx#onshutdown)
+- [OnDomReady](../reference/options.mdx#ondomready)
+
+Note: [OnDomReady](../reference/options.mdx#ondomready) replaces the `wails:ready` system event in v1.
+
+These methods can be standard functions, but a common practice is to have them part of a struct:
+
+```go title="v2"
+ basic := NewBasicApp()
+ err := wails.Run(&options.App{
+ /* Other Options */
+ OnStartup: basic.startup,
+ OnShutdown: basic.shutdown,
+ OnDomReady: basic.domready,
+ })
+...
+type Basic struct {
+ ctx context.Context
+}
+func (b *Basic) startup(ctx context.Context) {
+ b.ctx = ctx
+}
+...
+```
+
+### Runtime
+
+The runtime in v2 is much richer than v1 with support for menus, window manipulation
+and better dialogs. The signature of the methods has changed slightly - please refer
+the the [Runtime Reference](../reference/runtime/intro.mdx).
+
+In v1, the [runtime](../reference/runtime/intro.mdx) was available via a struct passed to `WailsInit()`.
+In v2, the runtime has been moved out to its own package. Each method in the runtime takes the
+`context.Context` that is passed to the [OnStartup](../reference/options.mdx#onstartup) method.
+
+```go title="Runtime Example"
+package main
+
+import "github.com/wailsapp/wails/v2/pkg/runtime"
+
+type Basic struct {
+ ctx context.Context
+}
+
+// startup is called at application startup
+func (a *App) startup(ctx context.Context) {
+ a.ctx = ctx
+ runtime.LogInfo(ctx, "Application Startup called!")
+}
+
+```
+
+### Assets
+
+The _biggest_ change in v2 is how assets are handled.
+
+In v1, assets were passed via 2 application options:
+
+- `JS` - The application's Javascript
+- `CSS` - The application's CSS
+
+This meant that the responsibility of generating a single JS and CSS file was on the
+developer. This essentially required the use of complicated packers such as webpack.
+
+In v2, Wails makes no assumptions about your frontend assets, just like a webserver.
+All of your application assets are passed to the application options as an `embed.FS`.
+
+**This means there is no requirement to bundle your assets, encode images as Base64 or
+attempt the dark art of bundler configuration to use custom fonts**.
+
+At startup, Wails
+will scan the given `embed.FS` for `index.html` and use its location as the root path
+for all the other application assets - just like a webserver would.
+
+Example: An application has the following project layout. All final assets are placed in the
+`frontend/dist` directory:
+
+```shell
+.
+βββ build/
+βββ frontend/
+β βββ dist/
+β βββ index.html
+β βββ main.js
+β βββ main.css
+β βββ logo.svg
+βββ main.go
+βββ wails.json
+```
+
+Those assets may be used by the application by simply creating an `embed.FS`:
+
+```go title="Assets Example"
+//go:embed frontend/dist
+var assets embed.FS
+
+func main() {
+ err := wails.Run(&options.App{
+ /* Other Options */
+ Assets: assets,
+ })
+}
+```
+
+Of course, bundlers can be used if you wish to. The only requirement is to pass
+the final application assets directory to Wails using an `embed.FS` in the `Assets`
+key of the [application options](../reference/options.mdx#application-options).
+
+### Project Configuration
+
+In v1, the project configuration was stored in the `project.json` file in the project root.
+In v2, the project configuration is stored in the `wails.json` file in the project root.
+
+The format of the file is slightly different. Here is a comparison:
+
+
+
+ | v1 | v2 | Notes |
+ | ------------------ | ---------------- | --------------------------------------------------- |
+ | name | name | |
+ | description | | Removed |
+ | author / name | author / name | |
+ | author / email | author / email | |
+ | version | version | |
+ | binaryname | outputfilename | Changed |
+ | frontend / dir | | Removed |
+ | frontend / install | frontend:install | Changed |
+ | frontend / build | frontend:build | Changed |
+ | frontend / bridge | | Removed |
+ | frontend / serve | | Removed |
+ | tags | | Removed |
+ | | wailsjsdir | The directory to generate wailsjs modules |
+ | | assetdir | The directory of the compiled frontend assets for `dev` mode. This is normally inferred and could be
+ left empty. |
+ | | reloaddirs | Comma separated list of additional directories to watch for changes and to trigger reloads in `dev`
+ mode. This is only needed for some more advanced asset configurations. |
+
+
+
+## Publishing Templates
+
+Publishing a template is simply pushing the files to GitHub. The following best practice is encouraged:
+
+- Remove any unwanted files and directories (such as `.git`) from your frontend directory
+- Ensure that `template.json` is complete, especially `helpurl`
+- Push the files to GitHub
+- Create a PR on the [Community Templates](../community/templates.mdx) page
+- Announce the template on the [Template Announcement](https://github.com/wailsapp/wails/discussions/825) discussion board
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/troubleshooting.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/troubleshooting.mdx
new file mode 100644
index 000000000..83b6b9972
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/troubleshooting.mdx
@@ -0,0 +1,70 @@
+# Troubleshooting
+
+An assortment of troubleshooting tips.
+
+## My application is displaying a white/blank screen
+
+Check that your application includes the assets from the correct directory. In your `main.go` file, you will have
+something similar to the following code:
+
+```go
+//go:embed frontend/dist
+var assets embed.FS
+```
+Check that `frontend/dist` contains your application assets.
+
+## Mac application not valid
+
+If your built application looks like this in finder:
+
+
+
+
+
+it's likely that your application's `info.plist` is invalid. Update the file in `build/.app/Contents/info.plist`
+and check if the data is valid, EG check the binary name is correct. To persist the changes, copy the file back to
+the `build/darwin` directory.
+
+## Cannot call backend method from frontend with variadic arguments
+
+If you have a backend method defined with variadic parameters, eg:
+```go
+func (a *App) TestFunc(msg string, args ...interface{}) error {
+ // Code
+}
+```
+calling this method from the frontend like this will fail:
+```js
+var msg = "Hello: "
+var args = ["Go", "JS"]
+window.go.main.App.TestFunc(msg, ...args).then((result) => {
+ //do things here
+}).catch((error) => {
+ //handle error
+});
+```
+Workaround:
+```js
+var msg = "Hello "
+var args = ["Go", "JS"]
+window.go.main.App.TestFunc(msg, args).then((result) => { //without the 3 dots
+ //do things here
+}).catch((error) => {
+ //handle error
+});
+```
+Credit: https://github.com/wailsapp/wails/issues/1186
+
+## I'm having getting proxy errors when trying to install Wails
+
+If you are getting errors like this:
+```
+"https://proxy.golang.org/github.com/wailsapp/wails/cmd/wails/@v/list": dial tcp 172.217.163.49:443: connectex: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.
+```
+it's probably because the official Go Proxy is being blocked (Users in China have reported this).
+The solution is to set up the proxy manually, eg:
+```
+go env -w GO111MODULE=on
+go env -w GOPROXY=https://goproxy.cn,direct
+```
+Source: https://github.com/wailsapp/wails/issues/1233
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/windows-installer.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/windows-installer.mdx
new file mode 100644
index 000000000..76f91dd70
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/windows-installer.mdx
@@ -0,0 +1,51 @@
+# NSIS installer
+
+
+
+
+
+Wails supports generating Windows installers using the [NSIS installer](https://nsis.sourceforge.io/).
+
+## Installing NSIS
+
+### Windows
+
+The installer is available on the [NSIS Download](https://nsis.sourceforge.io/Download) page.
+
+If you use the chocolatey package manager, run the following script:
+```
+choco install nsis
+```
+If you install NSIS manually, you need to add the *Bin* folder, which contains `makensis.exe`, in your NSIS installation to your path.
+[Here](https://www.architectryan.com/2018/03/17/add-to-the-path-on-windows-10/) is a good tutorial on how to add to path on Windows.
+
+### Linux
+
+The `nsis` package should be available through your distribution's package manager.
+
+### MacOS
+
+NSIS is available to install through homebrew: `brew install nsis`.
+
+## Generating the installer
+
+When a new project is created, Wails generates the NSIS configuration files in `build/windows/installer`. The config
+data is read from `installer/info.json` and that is configured to use the project's `wails.json` Info section:
+
+```json
+// ...
+ "Info": {
+ "companyName": "My Company Name",
+ "productName": "Wails Vite",
+ "productVersion": "1.0.0",
+ "copyright": "Copyright.........",
+ "comments": "Built using Wails (https://wails.io)"
+ },
+```
+
+To generate an installer for your application, use the `-nsis` flag with `wails build`:
+```
+wails build -nsis
+```
+
+The installer will now be available in the `build/bin` directory.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/guides/windows.mdx b/website/versioned_docs/version-v2.0.0-beta.35/guides/windows.mdx
new file mode 100644
index 000000000..53e456825
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/guides/windows.mdx
@@ -0,0 +1,36 @@
+# Windows
+
+This page has miscellaneous guides related to developing Wails applications for Windows.
+
+## Handling the WebView2 Runtime Dependency
+
+Wails applications built for Windows have a runtime requirement on the Microsoft [WebView2 Runtime](https://developer.microsoft.com/en-us/microsoft-edge/webview2/).
+Windows 11 will have this installed by default, but some machines won't. Wails offers an easy approach to dealing with this dependency.
+
+By using the `-webview2` flag when building, you can decide what your application will do when a suitable runtime is not detected (including if the installed runtime is too old).
+The four options are:
+
+1. Download
+2. Embed
+3. Browser
+4. Error
+
+### Download
+
+This option will prompt the user that no suitable runtime has been found and then offer to download and run the official
+bootstrapper from Microsoft's WebView2 site. If the user proceeds, the official bootstrapper will be downloaded and run.
+
+### Embed
+
+This option embeds the official bootstrapper within the application. If no suitable runtime has been found, the
+application will offer to run the bootstrapper. This adds ~150k to the binary size.
+
+### Browser
+
+This option will prompt the user that no suitable runtime has been found and then offer to open a browser to the official
+WebView2 page where the bootstrapper can be downloaded and installed. The application will then exit, leaving the installation
+up to the user.
+
+### Error
+
+If no suitable runtime is found, an error is given to the user and no further action taken.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/howdoesitwork.mdx b/website/versioned_docs/version-v2.0.0-beta.35/howdoesitwork.mdx
new file mode 100644
index 000000000..c22aada7a
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/howdoesitwork.mdx
@@ -0,0 +1,403 @@
+---
+sidebar_position: 20
+---
+
+# How does it work?
+
+A Wails application is a standard Go application, with a webkit frontend. The Go part of the application consists of the
+application code and a runtime library that provides a number of useful operations, like controlling the application
+window. The frontend is a webkit window that will display the frontend assets. Also available to the frontend is a Javascript
+version of the runtime library. Finally, it is possible to bind Go methods to the frontend, and these will appear as
+Javascript methods that can be called, just as if they were local Javascript methods.
+
+
+
+
+
+## The Main Application
+
+### Overview
+
+The main application consists of a single call to `wails.Run()`. It accepts the
+application configuration which describes the size of the application window, the window title,
+what assets to use, etc. A basic application might look like this:
+
+```go title="main.go"
+package main
+
+import (
+ "embed"
+ "log"
+
+ "github.com/wailsapp/wails/v2"
+ "github.com/wailsapp/wails/v2/pkg/options"
+)
+
+//go:embed frontend/dist
+var assets embed.FS
+
+func main() {
+
+ app := &App{}
+
+ err := wails.Run(&options.App{
+ Title: "Basic Demo",
+ Width: 1024,
+ Height: 768,
+ Assets: &assets,
+ OnStartup: app.startup,
+ OnShutdown: app.shutdown,
+ Bind: []interface{}{
+ app,
+ },
+ })
+ if err != nil {
+ log.Fatal(err)
+ }
+}
+
+
+type App struct {
+ ctx context.Context
+}
+
+func (b *App) startup(ctx context.Context) {
+ b.ctx = ctx
+}
+
+func (b *App) shutdown(ctx context.Context) {}
+
+func (b *App) Greet(name string) string {
+ return fmt.Sprintf("Hello %s!", name)
+}
+```
+
+### Options rundown
+
+This example has the following options set:
+
+- `Title` - The text that should appear in the window's title bar
+- `Width` & `Height` - The dimensions of the window
+- `Assets` - The application's frontend assets
+- `OnStartup` - A callback for when the window is created and is about to start loading the frontend assets
+- `OnShutdown` - A callback for when the application is about to quit
+- `Bind` - A slice of struct instances that we wish to expose to the frontend
+
+A full list of application options can be found in the [Options Reference](reference/options).
+
+#### Assets
+
+The `Assets` option is mandatory as you can't have a Wails application without frontend assets. Those assets can be
+any files you would expect to find in a web application - html, js, css, svg, png, etc. **There is no requirement to
+generate asset bundles** - plain files will do. When the application starts, it will attempt to load `index.html`
+from your assets and the frontend will essentially work as a browser from that point on. It is worth noting that
+there is no requirement on where in the `embed.FS` the files live. It is likely that the embed path uses a nested
+directory relative to your main application code, such as `frontend/dist`:
+
+```go title="main.go"
+//go:embed frontend/dist
+var assets embed.FS
+```
+
+At startup, Wails will iterate the embedded files looking for the directory containing `index.html`. All other assets will be loaded relative
+to this directory.
+
+As production binaries use the files contained in `embed.FS`, there are no external files required to be shipped with
+the application.
+
+When running in development mode using the `wails dev` command, the assets are loaded off disk, and any changes result
+in a "live reload". The location of the assets will be inferred from the `embed.FS`.
+
+More details can be found in the [Application Development Guide](guides/application-development.mdx).
+
+#### Application Lifecycle Callbacks
+
+Just before the frontend is about to load `index.html`, a callback is made to the function provided in [OnStartup](reference/options.mdx#onstartup).
+A standard Go context is passed to this method. This context is required when calling the runtime so a standard pattern is to save
+a reference to in this method. Just before the application shuts down, the [OnShutdown](reference/options.mdx#onshutdown) callback is called in the same way,
+again with the context. There is also an [OnDomReady](reference/options.mdx#ondomready) callback for when the frontend
+has completed loading all assets in `index.html` and is equivalent of the [`body onload`](https://www.w3schools.com/jsref/event_onload.asp) event in Javascript.
+It is also possible to hook into the window close (or application quit) event by setting the
+option [OnBeforeClose](reference/options.mdx#onbeforeclose).
+
+#### Method Binding
+
+The `Bind` option is one of the most important options in a Wails application. It specifies which struct methods
+to expose to the frontend. Think of structs like "controllers" in a traditional web application. When the application
+starts, it examines the struct instances listed in the `Bind` field in the options, determines which methods are
+public (starts with an uppercase letter) and will generate Javascript versions of those methods that can be called
+by the frontend code.
+
+:::info Note
+
+Wails requires that you pass in an *instance* of the struct for it to bind it correctly
+
+:::
+
+In this example, we create a new `App` instance and then add this instance to the `Bind` option in `wails.Run`:
+
+```go {16,24} title="main.go"
+package main
+
+import (
+ "embed"
+ "log"
+
+ "github.com/wailsapp/wails/v2"
+ "github.com/wailsapp/wails/v2/pkg/options"
+)
+
+//go:embed frontend/dist
+var assets embed.FS
+
+func main() {
+
+ app := &App{}
+
+ err := wails.Run(&options.App{
+ Title: "Basic Demo",
+ Width: 1024,
+ Height: 768,
+ Assets: &assets,
+ Bind: []interface{}{
+ app,
+ },
+ })
+ if err != nil {
+ log.Fatal(err)
+ }
+}
+
+
+type App struct {
+ ctx context.Context
+}
+
+func (a *App) Greet(name string) string {
+ return fmt.Sprintf("Hello %s!", name)
+}
+```
+
+You may bind as many structs as you like. Just make sure you create an instance of it and pass it in `Bind`:
+
+```go {8-10}
+ //...
+ err := wails.Run(&options.App{
+ Title: "Basic Demo",
+ Width: 1024,
+ Height: 768,
+ Assets: &assets,
+ Bind: []interface{}{
+ app,
+ &mystruct1{},
+ &mystruct2{},
+ },
+ })
+
+```
+
+When you run `wails dev` (or `wails generate module`), a frontend module will be generated containing the following:
+ - Javascript bindings for all bound methods
+ - Typescript declarations for all bound methods
+ - Typescript definitions for all Go structs used as inputs or outputs by the bound methods
+
+This makes it incredibly simple to call Go code from the frontend, using the same strongly typed datastructures.
+
+## The Frontend
+
+### Overview
+
+The frontend is a collection of files rendered by webkit. It''s like a browser and webserver in one.
+There is virtually[^1] no limit to which frameworks or libraries you can use. The main points of interaction between
+the frontend and your Go code are:
+
+- Calling bound Go methods
+- Calling runtime methods
+
+[^1]:
+There is a very small subset of libraries that use features unsupported in WebViews. There are often alternatives and
+workarounds for such cases.
+
+### Calling bound Go methods
+
+When you run your application with `wails dev`, it will automatically generate Javascript bindings for your structs in a
+directory called `wailsjs/go` (You can also do this by running `wails generate module`). The generated files mirror the
+package names in your application. In the example above, we bind `app`, which has one public method `Greet`. This will
+lead to the generation of the following files:
+
+```bash
+wailsjs
+ ββgo
+ ββmain
+ ββApp.d.ts
+ ββApp.js
+```
+Here we can see that there is a `main` package that contains the Javascript bindings for the bound `App` struct, as well
+as the Typescript declaration file for those methods. To call `Greet` from our frontend, we simply import the method and
+call it like a regular Javascript function:
+
+```javascript
+ // ...
+ import {Greet} from '../wailsjs/go/main/App'
+
+ function doGreeting(name) {
+ Greet(name).then((result) => {
+ // Do something with result
+ })
+ }
+```
+The Typescript declaration file gives you the correct types for the bound methods:
+
+```ts
+export function Greet(arg1:string):Promise;
+```
+
+The generated methods return a Promise. A successful call will result in the first return value from the Go call to be passed
+to the `resolve` handler. An unsuccessful call is when a Go method that has an error type as it''s second return value,
+passes an error instance back to the caller. This is passed back via the `reject` handler.
+In the example above, `Greet` only returns a `string` so the Javascript call will never reject - unless invalid data
+is passed to it.
+
+All data types are correctly translated between Go and Javascript. Even structs. If you return a struct from a Go call,
+it will be returned to your frontend as a Javascript class. Note: If you wish to use structs, you **must** define
+`json` struct tags for your fields!
+
+:::info Note
+Anonymous nested structs are not supported at this time.
+:::
+
+It is possible to send structs back to Go. Any Javascript map/class passed as an argument that
+is expecting a struct, will be converted to that struct type. To make this process a lot easier, in `dev` mode,
+a TypeScript module is generated, defining all the struct types used in bound methods. Using this module, it''s possible
+to construct and send native Javascript objects to the Go code.
+
+There is also support for Go methods that use structs in their signature. All Go structs
+specified by a bound method (either as parameters or return types) will have Typescript versions auto
+generated as part of the Go code wrapper module. Using these, it''s possible to share the same data
+model between Go and Javascript.
+
+Example: We update our `Greet` method to accept a `Person` instead of a string:
+
+```go title="main.go"
+type Person struct {
+ Name string `json:"name"`
+ Age uint8 `json:"age"`
+ Address *Address `json:"address"`
+}
+
+type Address struct {
+ Street string `json:"street"`
+ Postcode string `json:"postcode"`
+}
+
+func (a *App) Greet(p Person) string {
+ return fmt.Sprintf("Hello %s (Age: %d)!", p.Name, p.Age)
+}
+```
+
+The `wailsjs/go/main/App.js` file will still have the following code:
+
+```js title="App.js"
+export function Greet(arg1) {
+ return window['go']['main']['App']['Greet'](arg1);
+}
+```
+
+But the `wailsjs/go/main/App.d.ts` file will be updated with the following code:
+
+```ts title="App.d.ts"
+import {main} from '../models';
+
+export function Greet(arg1:main.Person):Promise;
+```
+
+As we can see, the "main" namespace is imported from a new "models.ts" file. This file contains all the struct definitions
+used by our bound methods. In this example, this is a `Person` struct. If we look at `models.ts`, we can see how the models
+are defined:
+
+```ts title="models.ts"
+export namespace main {
+
+ export class Address {
+ street: string;
+ postcode: string;
+
+ static createFrom(source: any = {}) {
+ return new Address(source);
+ }
+
+ constructor(source: any = {}) {
+ if ('string' === typeof source) source = JSON.parse(source);
+ this.street = source["street"];
+ this.postcode = source["postcode"];
+ }
+ }
+ export class Person {
+ name: string;
+ age: number;
+ address?: Address;
+
+ static createFrom(source: any = {}) {
+ return new Person(source);
+ }
+
+ constructor(source: any = {}) {
+ if ('string' === typeof source) source = JSON.parse(source);
+ this.name = source["name"];
+ this.age = source["age"];
+ this.address = this.convertValues(source["address"], Address);
+ }
+
+ convertValues(a: any, classs: any, asMap: boolean = false): any {
+ if (!a) {
+ return a;
+ }
+ if (a.slice) {
+ return (a as any[]).map(elem => this.convertValues(elem, classs));
+ } else if ("object" === typeof a) {
+ if (asMap) {
+ for (const key of Object.keys(a)) {
+ a[key] = new classs(a[key]);
+ }
+ return a;
+ }
+ return new classs(a);
+ }
+ return a;
+ }
+ }
+}
+```
+
+So long as you have TypeScript as part of your frontend build configuration, you can use these models in
+the following way:
+
+```js title="mycode.js"
+ import {Greet} from '../wailsjs/go/main/App'
+ import {main} from '../wailsjs/go/models'
+
+ function generate() {
+ let person = new main.Person()
+ person.name = "Peter"
+ person.age = 27
+ Greet(person).then((result) => {
+ console.log(result)
+ })
+ }
+```
+
+The combination of generated bindings and TypeScript models makes for a powerful development environment.
+
+More information on Binding can be found in the [Binding Methods](guides/application-development.mdx#binding-methods)
+section of the [Application Development Guide](guides/application-development.mdx).
+
+### Calling runtime methods
+
+The Javascript runtime is located at `window.runtime` and contains many methods to do various
+tasks such as emit an event or perform logging operations:
+
+```js title="mycode.js"
+window.runtime.EventsEmit("my-event", 1);
+```
+
+More details about the JS runtime can be found in the [Runtime Reference](reference/runtime/intro).
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/introduction.mdx b/website/versioned_docs/version-v2.0.0-beta.35/introduction.mdx
new file mode 100644
index 000000000..82df8ed4d
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/introduction.mdx
@@ -0,0 +1,78 @@
+---
+sidebar_position: 1
+---
+
+# Introduction
+
+## Overview
+
+Wails is a project that enables you to write desktop apps using Go and web technologies.
+
+Consider it a lightweight and fast Electron alternative for Go. You can easily build applications with the flexibility
+and power of Go, combined with a rich, modern frontend.
+
+Wails doesn't hold back with the eye candy either! This is [xbar](https://xbarapp.com) - a desktop application for MacOS
+written using Wails. It has menus, supports light and dark desktop themes, and the main window uses translucency that
+gives it that 'frosty' effect of a native app.
+
+
+
+
+When clicked, that will open an about message box:
+
+
+
+
+
+
+## Linux Specific Options
+
+### Icon
+
+Name: Icon
+
+Type: []byte
+
+Sets up the icon representing the window. This icon is used when the window is minimized (also known as iconified).
+Some window managers or desktop environments may also place it in the window frame, or display it in other contexts.
+On others, the icon is not used at all, so your mileage may vary.
+
+NOTE: Gnome on Wayland at least does not display this icon. To have a application icon there, a `.desktop` file has to be used.
+On KDE it should work.
+
+The icon should be provided in whatever size it was naturally drawn; that is, donβt scale the image before passing it.
+Scaling is postponed until the last minute, when the desired final size is known, to allow best quality.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/project-config.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/project-config.mdx
new file mode 100644
index 000000000..178504a63
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/project-config.mdx
@@ -0,0 +1,45 @@
+---
+sidebar_position: 5
+---
+
+# Project Config
+
+The project config resides in the `wails.json` file in the project directory. The structure of the config is:
+
+```json
+{
+ "name": "[The project name]",
+ "assetdir": "[Relative path to the directory containing the compiled assets, this is normally inferred and could be left empty]",
+ "reloaddirs": "[Additional directories to trigger reloads (comma separated), this is only used for some advanced asset configurations]",
+ "frontend:install": "[The command to install node dependencies, run in the frontend directory - often `npm install`]",
+ "frontend:build": "[The command to build the assets, run in the frontend directory - often `npm run build`]",
+ "frontend:dev": "[This command is the dev equivalent of frontend:build. If not specified falls back to frontend:build]",
+ "frontend:dev:watcher": "[This command is run in a separate process on `wails dev`. Useful for 3rd party watchers or starting 3d party dev servers]",
+ "frontend:dev:serverUrl": "[URL to a 3rd party dev server to be used to serve assets, EG Vite",
+ "wailsjsdir": "[Relative path to the directory that the auto-generated JS modules will be created]",
+ "version": "[Project config version]",
+ "outputfilename": "[The name of the binary]",
+ "debounceMS": 100, // The default time the dev server waits to reload when it detects a vhange in assets
+ "devServer": "[Address to bind the wails dev sever to. Default: localhost:34115]",
+ "appargs": "[Arguments passed to the application in shell style when in dev mode]",
+ "runNonNativeBuildHooks": false, // Defines if build hooks should be run though they are defined for an OS other than the host OS.
+ "postBuildHooks": {
+ "GOOS/GOARCH": "[The command that will be executed after a build of the specified GOOS/GOARCH: ${platform} is replaced with the "GOOS/GOARCH" and ${bin} with the path to the compiled binary. The "GOOS/GOARCH" hook is executed before the "GOOS/*" and "*/*" hook.]",
+ "GOOS/*": "[The command that will be executed after a build of the specified GOOS: ${platform} is replaced with the "GOOS/GOARCH" and ${bin} with the path to the compiled binary. The "GOOS/*" hook is executed before the "*/*" hook.]",
+ "*/*": "[The command that will be executed after every build: ${platform} is replaced with the "GOOS/GOARCH" and ${bin} with the path to the compiled binary.]"
+ },
+ "info": { // Data used to populate manifests and version info.
+ "companyName": "[The company name. Default: [The project name]]",
+ "productName": "[The product name. Default: [The project name]]",
+ "productVersion": "[The version of the product. Default: '1.0.0']",
+ "copyright": "[The copyright of the product. Default: 'Copyright.........']",
+ "comments": "[A short comment of the app. Default: 'Built using Wails (https://wails.app)']"
+ },
+ "nsisType": "['multiple': One installer per achitecture. 'single': Single universal installer for all architectures being built. Default: 'multiple']"
+}
+```
+
+This file is read by the Wails CLI when running `wails build` or `wails dev`.
+
+The `assetdir`, `reloaddirs`, `wailsjsdir`, `debounceMS`, `devserver` and `frontenddevserverurl` flags in `wails build/dev` will update the project config
+and thus become defaults for subsequent runs.
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/_category_.json b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/_category_.json
new file mode 100644
index 000000000..ac6d55488
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Runtime",
+ "position": 1
+}
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/browser.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/browser.mdx
new file mode 100644
index 000000000..1cb407d49
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/browser.mdx
@@ -0,0 +1,20 @@
+---
+sidebar_position: 7
+---
+
+# Browser
+
+## Overview
+
+These methods are related to the system browser.
+
+### BrowserOpenURL
+Go Signature: `BrowserOpenURL(ctx context.Context, url string)`
+
+JS Signature: `BrowserOpenURL(url string)`
+
+Opens the given URL in the system browser.
+
+
+
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/dialog.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/dialog.mdx
new file mode 100644
index 000000000..1f8a4000c
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/dialog.mdx
@@ -0,0 +1,268 @@
+---
+sidebar_position: 5
+---
+
+# Dialog
+
+## Overview
+
+This part of the runtime provides access to native dialogs, such as File Selectors and Message boxes.
+
+:::info Javascript
+Dialog is currently unsupported in the JS runtime.
+:::
+
+### OpenDirectoryDialog
+
+Opens a dialog that prompts the user to select a directory. Can be customised using [OpenDialogOptions](#opendialogoptions).
+
+Go Signature: `OpenDirectoryDialog(ctx context.Context, dialogOptions OpenDialogOptions) (string, error)`
+
+Returns: Selected directory (blank if the user cancelled) or an error
+
+
+### OpenFileDialog
+
+Opens a dialog that prompts the user to select a file. Can be customised using [OpenDialogOptions](#opendialogoptions).
+
+Go Signature: `OpenFileDialog(ctx context.Context, dialogOptions OpenDialogOptions) (string, error)`
+
+Returns: Selected file (blank if the user cancelled) or an error
+
+
+
+### OpenMultipleFilesDialog
+
+Opens a dialog that prompts the user to select multiple files. Can be customised using [OpenDialogOptions](#opendialogoptions).
+
+Go Signature: `OpenMultipleFilesDialog(ctx context.Context, dialogOptions OpenDialogOptions) ([]string, error)`
+
+Returns: Selected files (nil if the user cancelled) or an error
+
+
+
+### SaveFileDialog
+
+Opens a dialog that prompts the user to select a filename for the purposes of saving. Can be customised using [SaveDialogOptions](#savedialogoptions).
+
+Go Signature: `SaveFileDialog(ctx context.Context, dialogOptions SaveDialogOptions) (string, error)`
+
+Returns: The selected file (blank if the user cancelled) or an error
+
+
+
+### MessageDialog
+
+Displays a message using a message dialog. Can be customised using [MessageDialogOptions](#messagedialogoptions).
+
+Go Signature: `MessageDialog(ctx context.Context, dialogOptions MessageDialogOptions) (string, error)`
+
+Returns: The text of the selected button or an error
+
+## Options
+
+### OpenDialogOptions
+
+```go
+type OpenDialogOptions struct {
+ DefaultDirectory string
+ DefaultFilename string
+ Title string
+ Filters []FileFilter
+ ShowHiddenFiles bool
+ CanCreateDirectories bool
+ ResolvesAliases bool
+ TreatPackagesAsDirectories bool
+}
+```
+| Field | Description | Win | Mac | Lin |
+| -------------------------- | ---------------------------------------------- | --- | --- | --- |
+| DefaultDirectory | The directory the dialog will show when opened | β | β | β |
+| DefaultFilename | The default filename | β | β | β |
+| Title | Title for the dialog | β | β | β |
+| [Filters](#filefilter) | A list of file filters | β | β | β |
+| ShowHiddenFiles | Show files hidden by the system | | β | β |
+| CanCreateDirectories | Allow user to create directories | | β | |
+| ResolvesAliases | If true, returns the file not the alias | | β | |
+| TreatPackagesAsDirectories | Allow navigating into packages | | β | |
+
+
+### SaveDialogOptions
+
+```go
+type SaveDialogOptions struct {
+ DefaultDirectory string
+ DefaultFilename string
+ Title string
+ Filters []FileFilter
+ ShowHiddenFiles bool
+ CanCreateDirectories bool
+ TreatPackagesAsDirectories bool
+}
+```
+
+| Field | Description | Win | Mac | Lin |
+| -------------------------- | ---------------------------------------------- | --- | --- | --- |
+| DefaultDirectory | The directory the dialog will show when opened | β | β | β |
+| DefaultFilename | The default filename | β | β | β |
+| Title | Title for the dialog | β | β | β |
+| [Filters](#filefilter) | A list of file filters | β | β | β |
+| ShowHiddenFiles | Show files hidden by the system | | β | β |
+| CanCreateDirectories | Allow user to create directories | | β | |
+| TreatPackagesAsDirectories | Allow navigating into packages | | β | |
+
+### MessageDialogOptions
+
+```go
+type MessageDialogOptions struct {
+ Type DialogType
+ Title string
+ Message string
+ Buttons []string
+ DefaultButton string
+ CancelButton string
+}
+```
+| Field | Description | Win | Mac | Lin |
+| ------------- | ------------------------------------------------------------------------- | --- | --- | --- |
+| Type | The type of message dialog, eg question, info... | β | β | β |
+| Title | Title for the dialog | β | β | β |
+| Message | The message to show the user | β | β | β |
+| Buttons | A list of button titles | | β | |
+| DefaultButton | The button with this text should be treated as default. Bound to `return` | | β | |
+| CancelButton | The button with this text should be treated as cancel. Bound to `escape` | | β | |
+
+#### Windows
+
+Windows has standard dialog types in which the buttons are not customisable.
+The value returned will be one of: "Ok", "Cancel", "Abort", "Retry", "Ignore", "Yes", "No", "Try Again" or "Continue"
+
+#### Linux
+
+Linux has standard dialog types in which the buttons are not customisable.
+The value returned will be one of: "Ok", "Cancel", "Yes", "No"
+
+#### Mac
+
+A message dialog on Mac may specify up to 4 buttons. If no `DefaultButton` or `CancelButton` is given, the first button
+is considered default and is bound to the `return` key.
+
+For the following code:
+```go
+selection, err := runtime.MessageDialog(b.ctx, runtime.MessageDialogOptions{
+ Title: "It's your turn!",
+ Message: "Select a number",
+ Buttons: []string{"one", "two", "three", "four"},
+})
+```
+the first button is shown as default:
+
+
+
+
+
+And if we specify `DefaultButton` to be "two":
+```go
+selection, err := runtime.MessageDialog(b.ctx, runtime.MessageDialogOptions{
+ Title: "It's your turn!",
+ Message: "Select a number",
+ Buttons: []string{"one", "two", "three", "four"},
+ DefaultButton: "two",
+})
+```
+the second button is shown as default. When `return` is pressed, the value "two" is returned.
+
+
+
+
+
+If we now specify `CancelButton` to be "three":
+```go
+selection, err := runtime.MessageDialog(b.ctx, runtime.MessageDialogOptions{
+ Title: "It's your turn!",
+ Message: "Select a number",
+ Buttons: []string{"one", "two", "three", "four"},
+ DefaultButton: "two",
+ CancelButton: "three",
+})
+```
+the button with "three" is shown at the bottom of the dialog. When `escape` is pressed, the value "three" is returned:
+
+
+
+
+
+
+
+
+#### DialogType
+
+```go
+const (
+ InfoDialog DialogType = "info"
+ WarningDialog DialogType = "warning"
+ ErrorDialog DialogType = "error"
+ QuestionDialog DialogType = "question"
+ )
+```
+
+### FileFilter
+
+```go
+type FileFilter struct {
+ DisplayName string // Filter information EG: "Image Files (*.jpg, *.png)"
+ Pattern string // semi-colon separated list of extensions, EG: "*.jpg;*.png"
+}
+```
+
+#### Windows
+
+Windows allows you to use multiple file filters in dialog boxes. Each FileFilter will show up as a separate entry in the
+dialog:
+
+
+
+
+
+
+
+
+#### Linux
+
+Linux allows you to use multiple file filters in dialog boxes. Each FileFilter will show up as a separate entry in the
+dialog:
+
+
+
+
+
+
+
+
+
+#### Mac
+
+Mac dialogs only have the concept of a single set of patterns to filter files. If multiple FileFilters are provided,
+Wails will use all the Patterns defined.
+
+Example:
+```go
+ selection, err := runtime.OpenFileDialog(b.ctx, runtime.OpenDialogOptions{
+ Title: "Select File",
+ Filters: []runtime.FileFilter{
+ {
+ DisplayName: "Images (*.png;*.jpg)",
+ Pattern: "*.png;*.jpg",
+ }, {
+ DisplayName: "Videos (*.mov;*.mp4)",
+ Pattern: "*.mov;*.mp4",
+ },
+ },
+ })
+```
+This will result in the Open File dialog using `*.png,*.jpg,*.mov,*.mp4` as a filter.
\ No newline at end of file
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/events.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/events.mdx
new file mode 100644
index 000000000..c08f83c8a
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/events.mdx
@@ -0,0 +1,51 @@
+---
+sidebar_position: 2
+---
+
+# Events
+
+## Overview
+
+The Wails runtime provides a unified events system, where events can be emitted or received by either Go or Javascript.
+Optionally, data may be passed with the events. Listeners will receive the data in the local data types.
+
+### EventsOn
+
+Go Signature: `EventsOn(ctx context.Context, eventName string, callback func(optionalData ...interface{}))`
+
+JS Signature: `EventsOn(eventName string, callback function(optionalData?: any))`
+
+This method sets up a listener for the given event name. When an event of type `eventName` is [emitted](#EventsEmit),
+the callback is triggered. Any additional data sent with the emitted event will be passed to the callback.
+
+### EventsOff
+
+Go Signature: `EventsOff(ctx context.Context, eventName string)`
+
+JS Signature: `EventsOff(eventName string)`
+
+This method unregisters the listener for the given event name.
+
+### EventsOnce
+
+Go Signature: `EventsOnce(ctx context.Context, eventName string, callback func(optionalData ...interface{}))`
+
+JS Signature: `EventsOnce(eventName string, callback function(optionalData?: any))`
+
+This method sets up a listener for the given event name, but will only trigger once.
+
+### EventsOnMultiple
+
+Go Signature: `EventsOnMultiple(ctx context.Context, eventName string, callback func(optionalData ...interface{}), counter int)`
+
+JS Signature: `EventsOnMultiple(eventName string, callback function(optionalData?: any), counter int)`
+
+This method sets up a listener for the given event name, but will only trigger a maximum of `counter` times.
+
+### EventsEmit
+
+Go Signature: `EventsEmit(ctx context.Context, eventName string, optionalData ...interface{})`
+
+JS Signature: `EventsEmit(ctx context, optionalData function(optionalData?: any))`
+
+This method emits the given event. Optional data may be passed with the event. This will trigger any event listeners.
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/intro.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/intro.mdx
new file mode 100644
index 000000000..b3616f689
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/intro.mdx
@@ -0,0 +1,47 @@
+---
+sidebar_position: 1
+---
+
+# Introduction
+
+The runtime is a library that provides utility methods for your application. There is both a Go and Javascript runtime
+and the aim is to try and keep them at parity where possible.
+
+The Go Runtime is available through importing `github.com/wailsapp/wails/v2/pkg/runtime`. All methods in this package
+take a context as the first parameter. This context should be obtained from the [OnStartup](../options.mdx#onstartup)
+or [OnDomReady](../options.mdx#ondomready) hooks.
+
+:::info Note
+
+Whilst the context will be provided to the
+[OnStartup](../options.mdx#onstartup) method, there's no guarantee the runtime will work in this method as
+the window is initialising in a different thread. If
+you wish to call runtime methods at startup, use [OnDomReady](../options.mdx#ondomready).
+
+:::
+
+The Javascript library is available to the frontend via the `window.runtime` map. There is a runtime package generated when using `dev`
+mode that provides Typescript declarations for the runtime. This should be located in the `wailsjs` directory in your
+frontend directory.
+
+### Quit
+
+Go Signature: `Quit(ctx context.Context)`
+
+Quits the application.
+
+### Environment
+
+Go Signature: `Enviromnent(ctx context.Context) EnvironmentInfo`
+
+Returns details of the current environment.
+
+#### EnvironmentInfo
+
+```go
+type EnvironmentInfo struct {
+ BuildType string // Either "production", "debug" or "dev"
+}
+```
+
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/log.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/log.mdx
new file mode 100644
index 000000000..713838008
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/log.mdx
@@ -0,0 +1,153 @@
+---
+sidebar_position: 3
+---
+
+# Log
+
+## Overview
+
+The Wails runtime provides a logging mechanism that may be called from Go or Javascript. Like most
+loggers, there are a number of log levels:
+
+ - Trace
+ - Debug
+ - Info
+ - Warning
+ - Error
+ - Fatal
+
+The logger will output any log message at the current, or higher, log level. Example: The `Debug` log
+level will output all messages except `Trace` messages.
+
+### LogPrint
+
+Go Signature: `LogPrint(ctx context.Context, message string)`
+
+JS Signature: `LogPrint(message: string)`
+
+Logs the given message as a raw message.
+
+### LogPrintf
+
+Go Signature: `LogPrintf(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message as a raw message.
+
+### LogTrace
+
+Go Signature: `LogTrace(ctx context.Context, message string)`
+
+JS Signature: `LogTrace(message: string)`
+
+Logs the given message at the `Trace` log level.
+
+### LogTracef
+
+Go Signature: `LogTracef(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message at the `Trace` log level.
+
+### LogDebug
+
+Go Signature: `LogDebug(ctx context.Context, message string)`
+
+JS Signature: `LogDebug(message: string)`
+
+Logs the given message at the `Debug` log level.
+
+### LogDebugf
+
+Go Signature: `LogDebugf(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message at the `Debug` log level.
+
+### LogInfo
+
+Go Signature: `LogInfo(ctx context.Context, message string)`
+
+JS Signature: `LogInfo(message: string)`
+
+Logs the given message at the `Info` log level.
+
+### LogInfof
+
+Go Signature: `LogInfof(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message at the `Info` log level.
+
+### LogWarning
+
+Go Signature: `LogWarning(ctx context.Context, message string)`
+
+JS Signature: `LogWarning(message: string)`
+
+Logs the given message at the `Warning` log level.
+
+### LogWarningf
+
+Go Signature: `LogWarningf(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message at the `Warning` log level.
+
+### LogError
+
+Go Signature: `LogError(ctx context.Context, message string)`
+
+JS Signature: `LogError(message: string)`
+
+Logs the given message at the `Error` log level.
+
+### LogErrorf
+
+Go Signature: `LogErrorf(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message at the `Error` log level.
+
+### LogFatal
+
+Go Signature: `LogFatal(ctx context.Context, message string)`
+
+JS Signature: `LogFatal(message: string)`
+
+Logs the given message at the `Fatal` log level.
+
+### LogFatalf
+
+Go Signature: `LogFatalf(ctx context.Context, format string, args ...interface{})`
+
+Logs the given message at the `Fatal` log level.
+
+### LogSetLogLevel
+
+Go Signature: `LogSetLogLevel(ctx context.Context, level logger.LogLevel)`
+
+JS Signature: `LogSetLogLevel(level: number)`
+
+Sets the log level. In Javascript, the number relates to the following log levels:
+
+| Value | Log Level |
+| ----- | --------- |
+| 1 | Trace |
+| 2 | Debug |
+| 3 | Info |
+| 4 | Warning |
+| 5 | Error |
+
+## Using a Custom Logger
+
+A custom logger may be used by providing it using the [Logger](../options.mdx#logger)
+application option. The only requirement is that the logger implements the `logger.Logger` interface
+defined in `github.com/wailsapp/wails/v2/pkg/logger`:
+
+```go title="logger.go"
+type Logger interface {
+ Print(message string)
+ Trace(message string)
+ Debug(message string)
+ Info(message string)
+ Warning(message string)
+ Error(message string)
+ Fatal(message string)
+}
+```
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/menu.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/menu.mdx
new file mode 100644
index 000000000..95bed2d97
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/menu.mdx
@@ -0,0 +1,25 @@
+---
+sidebar_position: 6
+---
+
+# Menu
+
+## Overview
+
+These methods are related to the application menu.
+
+:::info Javascript
+Menu is currently unsupported in the JS runtime.
+:::
+
+### MenuSetApplicationMenu
+Go Signature: `MenuSetApplicationMenu(ctx context.Context, menu *menu.Menu)`
+
+Sets the application menu to the given [menu](../menus.mdx) .
+
+### MenuUpdateApplicationMenu
+Go Signature: `MenuUpdateApplicationMenu(ctx context.Context)`
+
+Updates the application menu, picking up any changes to the menu passed to `MenuSetApplicationMenu`.
+
+
diff --git a/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/window.mdx b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/window.mdx
new file mode 100644
index 000000000..915ca9ac4
--- /dev/null
+++ b/website/versioned_docs/version-v2.0.0-beta.35/reference/runtime/window.mdx
@@ -0,0 +1,216 @@
+---
+sidebar_position: 4
+---
+
+# Window
+
+## Overview
+
+These methods give control of the application window.
+
+### WindowSetTitle
+Go Signature: `WindowSetTitle(ctx context.Context, title string)`
+
+JS Signature: `WindowSetTitle(title: string)`
+
+Sets the text in the window title bar.
+
+### WindowFullscreen
+Go Signature: `WindowFullscreen(ctx context.Context)`
+
+JS Signature: `WindowFullscreen()`
+
+Makes the window full screen.
+
+### WindowUnfullscreen
+Go Signature: `WindowUnfullscreen(ctx context.Context)`
+
+JS Signature: `WindowUnfullscreen()`
+
+Restores the previous window dimensions and position prior to full screen.
+
+### WindowCenter
+Go Signature: `WindowCenter(ctx context.Context)`
+
+JS Signature: `WindowCenter()`
+
+Centers the window on the monitor the window is currently on.
+
+### WindowReload
+Go Signature: `WindowReload(ctx context.Context)`
+
+JS Signature: `WindowReload()`
+
+Performs a "reload" (Reloads current page).
+
+### WindowReloadApp
+Go Signature: `WindowReloadApp(ctx context.Context)`
+
+JS Signature: `WindowReloadApp()`
+
+Reloads the application frontend.
+
+### WindowSetSy
+
+### WindowSetSystemDefaultTheme
+Go Signature: `WindowSetSystemDefaultTheme(ctx context.Context)`
+
+JS Signature: `WindowSetSystemDefaultTheme()`
+
+Windows only.
+
+Sets window theme to system default (dark/light).
+
+### WindowSetLightTheme
+Go Signature: `WindowSetLightTheme(ctx context.Context)`
+
+JS Signature: `WindowSetLightTheme()`
+
+Windows only.
+
+Sets window theme to light.
+
+### WindowSetDarkTheme
+Go Signature: `WindowSetDarkTheme(ctx context.Context)`
+
+JS Signature: `WindowSetDarkTheme()`
+
+Windows only.
+
+Sets window theme to dark.
+
+### WindowShow
+Go Signature: `WindowShow(ctx context.Context)`
+
+JS Signature: `WindowShow()`
+
+Shows the window, if it is currently hidden.
+
+### WindowHide
+Go Signature: `WindowHide(ctx context.Context)`
+
+JS Signature: `WindowHide()`
+
+Hides the window, if it is currently visible.
+
+### WindowSetSize
+Go Signature: `WindowSetSize(ctx context.Context, width int, height int)`
+
+JS Signature: `WindowSetSize(size: Size)`
+
+Sets the width and height of the window.
+
+### WindowGetSize
+Go Signature: `WindowGetSize(ctx context.Context) (width int, height int)`
+
+JS Signature: `WindowGetSize() : Size`
+
+Gets the width and height of the window.
+
+### WindowSetMinSize
+Go Signature: `WindowSetMinSize(ctx context.Context, width int, height int)`
+
+JS Signature: `WindowSetMinSize(size: Size)`
+
+Sets the minimum window size.
+Will resize the window if the window is currently smaller than the given dimensions.
+
+Setting a size of `0,0` will disable this constraint.
+
+### WindowSetMaxSize
+Go Signature: `WindowSetMaxSize(ctx context.Context, width int, height int)`
+
+JS Signature: `WindowSetMaxSize(size: Size)`
+
+Sets the maximum window size.
+Will resize the window if the window is currently larger than the given dimensions.
+
+Setting a size of `0,0` will disable this constraint.
+
+### WindowSetPosition
+Go Signature: `WindowSetPosition(ctx context.Context, x int, y int)`
+
+JS Signature: `WindowSetPosition(position: Position)`
+
+Sets the window position relative to the monitor the window is currently on.
+
+### WindowGetPosition
+Go Signature: `WindowGetPosition(ctx context.Context) (x int, y int)`
+
+JS Signature: `WindowGetPosition() : Position`
+
+Gets the window position relative to the monitor the window is currently on.
+
+### WindowMaximise
+Go Signature: `WindowMaximise(ctx context.Context)`
+
+JS Signature: `WindowMaximise()`
+
+Maximises the window to fill the screen.
+
+### WindowUnmaximise
+Go Signature: `WindowUnmaximise(ctx context.Context)`
+
+JS Signature: `WindowUnmaximise()`
+
+Restores the window to the dimensions and position prior to maximising.
+
+### WindowToggleMaximise
+Go Signature: `WindowToggleMaximise(ctx context.Context)`
+
+JS Signature: `WindowToggleMaximise()`
+
+Toggles between Maximised and UnMaximised.
+
+### WindowMinimise
+Go Signature: `WindowMinimise(ctx context.Context)`
+
+JS Signature: `WindowMinimise()`
+
+Minimises the window.
+
+### WindowUnminimise
+Go Signature: `WindowUnminimise(ctx context.Context)`
+
+JS Signature: `WindowUnminimise()`
+
+Restores the window to the dimensions and position prior to minimising.
+
+### WindowSetRGBA
+Go Signature: `WindowSetRGBA(ctx context.Context, R, G, B, A uint8)`
+
+JS Signature: `WindowSetRGBA(R, G, B, A)`
+
+Sets the background colour of the window to the given RGBA colour definition.
+This colour will show through for all transparent pixels.
+
+Valid values for R, G, B and A are 0-255.
+
+:::info Windows
+
+On Windows, only alpha values of 0 or 255 are supported.
+Any value that is not 0 will be considered 255.
+
+:::
+
+## Typescript Object Definitions
+
+### Position
+
+```ts
+interface Position {
+ x: number;
+ y: number;
+}
+```
+
+### Size
+
+```ts
+interface Size {
+ w: number;
+ h: number;
+}
+```
+
+
diff --git a/website/versioned_sidebars/version-v2.0.0-beta.35-sidebars.json b/website/versioned_sidebars/version-v2.0.0-beta.35-sidebars.json
new file mode 100644
index 000000000..caea0c03b
--- /dev/null
+++ b/website/versioned_sidebars/version-v2.0.0-beta.35-sidebars.json
@@ -0,0 +1,8 @@
+{
+ "tutorialSidebar": [
+ {
+ "type": "autogenerated",
+ "dirName": "."
+ }
+ ]
+}
diff --git a/website/versions.json b/website/versions.json
index 146723fc9..b6fd4043d 100644
--- a/website/versions.json
+++ b/website/versions.json
@@ -1,3 +1,4 @@
[
+ "v2.0.0-beta.35",
"v2.0.0-beta.34"
]
+
+
+
+
+
+
+
+
+
+Name: AssetsHandler
+
+Type: http.Handler
+
+
+The assets handler is a generic `http.Handler` which will be called for any non GET request on the assets server
+and for GET requests which can not be served from the `assets` because the file is not found.
+
+| Value | Win | Mac | Lin |
+| ----------------------------- | --- | --- | --- |
+| GET | β
| β
| β
|
+| POST | β
| β
| β |
+| PUT | β
| β
| β |
+| PATCH | β
| β
| β |
+| DELETE | β
| β
| β |
+| Request Headers | β
| β
| β |
+| Request Body | β
| β
| β |
+| Request Body Streaming | β | β | β |
+| Response StatusCodes | β
| β
| β |
+| Response Headers | β
| β
| β |
+| Response Body | β
| β
| β
|
+| Response Body Streaming | β | β | β
|
+
+NOTE: Linux is currently very limited due to targeting a WebKit2GTK Version < 2.36.0. In the future some features will be
+supported by the introduction of WebKit2GTK 2.36.0+ support.
+
+NOTE: When used in combination with a Frontend DevServer there might be limitations, eg. Vite serves the index.html
+on every path, that does not contain a file extension.
+
+### Menu
+
+Name: Menu
+
+Type: \*menu.Menu
+
+The menu to be used by the application. More details about Menus in the [Menu Reference](../reference/runtime/menu.mdx).
+
+NOTE: On Mac, if no menu is specified, a default menu will be created.
+
+### Logger
+
+Name: Logger
+
+Type: logger.Logger
+
+Default: Logger to Stdout
+
+The logger to be used by the application. More details about logging in the [Log Reference](../reference/runtime/log.mdx).
+
+### LogLevel
+
+Name: LogLevel
+
+Type: logger.LogLevel
+
+Default: `Info` in dev mode, `Error` in production mode
+
+The default log level. More details about logging in the [Log Reference](../reference/runtime/log.mdx).
+
+### OnStartup
+
+Name: OnStartup
+
+Type: func(ctx context.Context)
+
+This callback is called after the frontend has been created, but before `index.html` has been loaded. It is given
+the application context.
+
+### OnDomReady
+
+Name: OnDomReady
+
+Type: func(ctx context.Context)
+
+This callback is called after the frontend has loaded `index.html` and its resources. It is given
+the application context.
+
+### OnShutdown
+
+Name: OnShutdown
+
+Type: func(ctx context.Context)
+
+This callback is called after the frontend has been destroyed, just before the application terminates. It is given
+the application context.
+
+### OnBeforeClose
+
+Name: OnBeforeClose
+
+Type: func(ctx context.Context) bool
+
+If this callback is set, it will be called when the application is about to quit, either by clicking the window close
+button or calling `runtime.Quit`. Returning true will cause the application to continue, false will continue shutdown
+as normal. This is good for confirming with the user that they wish to exit the program.
+
+Example:
+```go title=windowsapp.go
+func (b *App) beforeClose(ctx context.Context) (prevent bool) {
+ dialog, err := runtime.MessageDialog(ctx, runtime.MessageDialogOptions{
+ Type: runtime.QuestionDialog,
+ Title: "Quit?",
+ Message: "Are you sure you want to quit?",
+ })
+
+ if err != nil {
+ return false
+ }
+ return dialog != "Yes"
+}
+```
+
+### WindowStartState
+
+Name: WindowStartState
+
+Type: options.WindowStartState
+
+Defines how the window should present itself at startup.
+
+| Value | Win | Mac | Lin |
+| --------------- | --- | --- | --- |
+| Fullscreen | β
| β
| β
|
+| Maximised | β
| β
| β
|
+| Minimised | β
| β | β
|
+
+### Bind
+
+Name: Bind
+
+Type: []interface{}
+
+A slice of struct instances defining methods that need to be bound to the frontend.
+
+### Windows
+
+Name: Windows
+
+Type: \*windows.Options
+
+This defines [Windows specific options](#windows-specific-options).
+
+### Mac
+
+Name: Mac
+
+Type: \*mac.Options
+
+This defines [Mac specific options](#mac-specific-options).
+
+### Linux
+
+Name: Linux
+
+Type: \*linux.Options
+
+This defines [Linux specific options](#linux-specific-options).
+
+## Windows Specific Options
+
+### WebviewIsTransparent
+
+Name: WebviewIsTransparent
+
+Type: bool
+
+Setting this to `true` will make the webview background transparent when an alpha value of `0` is used.
+This means that if you use `rgba(0,0,0,0)`, the host window will show through.
+Often combined with [WindowIsTranslucent](#WindowIsTranslucent) to make frosty-looking applications.
+
+### WindowIsTranslucent
+
+Name: WindowIsTranslucent
+
+Type: bool
+
+Setting this to `true` will make the window background translucent. Often combined
+with [WebviewIsTransparent](#WebviewIsTransparent) to make frosty-looking applications.
+
+### DisableWindowIcon
+
+Name: DisableWindowIcon
+
+Type: bool
+
+Setting this to `true` will remove the icon in the top left corner of the title bar.
+
+### DisableFramelessWindowDecorations
+
+Name: DisableFramelessWindowDecorations
+
+Type: bool
+
+Setting this to `true` will remove the window decorations in [Frameless](#Frameless) mode. This means there will be no
+'Aero Shadow' and no 'Rounded Corners' shown for the window. Please note that 'Rounded Corners' are only supported on
+Windows 11.
+
+### WebviewUserDataPath
+
+Name: WebviewUserDataPath
+
+Type: string
+
+This defines the path where the WebView2 stores the user data. If empty `%APPDATA%\[BinaryName.exe]` will be used.
+
+### Theme
+
+Name: Theme
+
+Type: `windows.Theme`
+
+Minimum Windows Version: Windows 10 2004/20H1
+
+This defines the theme that the application should use:
+
+| Value | Description |
+| --------------- | ----------- |
+| SystemDefault | *Default*. The theme will be based on the system default. If the user changes their theme, the application will update to use the new setting |
+| Dark | The application will use a dark theme exclusively |
+| Light | The application will use a light theme exclusively |
+
+
+### CustomTheme
+
+Name: CustomTheme
+
+Type: `windows.CustomTheme`
+
+Minimum Windows Version: Windows 10/11 2009/21H2 Build 22000
+
+Allows you to specify custom colours for TitleBar, TitleText and Border for both light and dark mode, as well as
+when the window is active or inactive.
+
+#### CustomTheme
+
+The CustomTheme struct uses `int32` to specify the colour values. These are in the standard(!) Windows format of:
+`0x00BBGGAA`. A helper function is provided to do RGB conversions into this format: `windows.RGB(r,g,b uint8)`.
+
+NOTE: Any value not provided will default to black.
+
+```go
+type ThemeSettings struct {
+ DarkModeTitleBar int32
+ DarkModeTitleBarInactive int32
+ DarkModeTitleText int32
+ DarkModeTitleTextInactive int32
+ DarkModeBorder int32
+ DarkModeBorderInactive int32
+ LightModeTitleBar int32
+ LightModeTitleBarInactive int32
+ LightModeTitleText int32
+ LightModeTitleTextInactive int32
+ LightModeBorder int32
+ LightModeBorderInactive int32
+}
+```
+
+Example:
+```go
+ CustomTheme: &windows.ThemeSettings{
+ // Theme to use when window is active
+ DarkModeTitleBar: windows.RGB(255, 0, 0), // Red
+ DarkModeTitleText: windows.RGB(0, 255, 0), // Green
+ DarkModeBorder: windows.RGB(0, 0, 255), // Blue
+ LightModeTitleBar: windows.RGB(200, 200, 200),
+ LightModeTitleText: windows.RGB(20, 20, 20),
+ LightModeBorder: windows.RGB(200, 200, 200),
+ // Theme to use when window is inactive
+ DarkModeTitleBarInactive: windows.RGB(128, 0, 0),
+ DarkModeTitleTextInactive: windows.RGB(0, 128, 0),
+ DarkModeBorderInactive: windows.RGB(0, 0, 128),
+ LightModeTitleBarInactive: windows.RGB(100, 100, 100),
+ LightModeTitleTextInactive: windows.RGB(10, 10, 10),
+ LightModeBorderInactive: windows.RGB(100, 100, 100),
+ },
+```
+
+### Messages
+
+Name: Messages
+
+Type: `*windows.Messages`
+
+A struct of strings used by the webview2 installer if a valid webview2 runtime is not found.
+Customise this for any language you choose to support.
+
+## Mac Specific Options
+
+### TitleBar
+
+Name: TitleBar
+
+Type: [*mac.TitleBar](#titlebar-struct)
+
+The TitleBar struct provides the ability to configure the look and feel of the title bar.
+
+### Appearance
+
+Name: Appearance
+
+Type: [AppearanceType](#appearance-type)
+
+Appearance is used to set the style of your app in accordance with Apple's [NSAppearance](https://developer.apple.com/documentation/appkit/nsappearancename?language=objc) names.
+
+### WebviewIsTransparent
+
+Name: WebviewIsTransparent
+
+Type: bool
+
+Setting this to `true` will make the webview background transparent when an alpha value of `0` is used.
+This means that if you use `rgba(0,0,0,0)`, the host window will show through.
+Often combined with [WindowIsTranslucent](#WindowIsTranslucent) to make frosty-looking applications.
+
+### WindowIsTranslucent
+
+Name: WindowIsTranslucent
+
+Type: bool
+
+Setting this to `true` will make the window background translucent. Often combined
+with [WebviewIsTransparent](#WebviewIsTransparent) to make frosty-looking applications.
+
+### About
+
+Name: About
+
+Type: [About](#about-struct)
+
+This configuration lets you set the title, message and icon for the "About" menu item in the app menu created by the "AppMenu" role.
+
+#### Titlebar struct
+
+The titlebar of the application can be customised by using the TitleBar options:
+
+```go
+type TitleBar struct {
+ TitlebarAppearsTransparent bool
+ HideTitle bool
+ HideTitleBar bool
+ FullSizeContent bool
+ UseToolbar bool
+ HideToolbarSeparator bool
+}
+```
+
+| Name | Description |
+| ---- | ----------- |
+| TitlebarAppearsTransparent | Makes the titlebar transparent. This has the effect of hiding the titlebar and the content fill the window. [Apple Docs](https://developer.apple.com/documentation/appkit/nswindow/1419167-titlebarappearstransparent?language=objc) |
+| HideTitle | Hides the title of the window. [Apple Docs](https://developer.apple.com/documentation/appkit/nswindowtitlevisibility?language=objc) |
+| HideTitleBar | Removes [NSWindowStyleMaskTitled](https://developer.apple.com/documentation/appkit/nswindowstylemask/nswindowstylemasktitled/) from the style mask |
+| FullSizeContent | Makes the webview fill the entire window. [Apple Docs](https://developer.apple.com/documentation/appkit/nswindowstylemask/nswindowstylemaskfullsizecontentview)|
+| UseToolbar | Adds a default toolbar to the window. [Apple Docs](https://developer.apple.com/documentation/appkit/nstoolbar?language=objc) |
+| HideToolbarSeparator | Removes the line beneath the toolbar. [Apple Docs](https://developer.apple.com/documentation/appkit/nstoolbar/1516954-showsbaselineseparator?language=objc) |
+
+Preconfigured titlebar settings are available:
+
+| Setting | Example |
+| ------- | ------- |
+|`mac.TitleBarDefault()` |  |
+|`mac.TitleBarHidden()` |  |
+|`mac.TitleBarHiddenInset()` |  |
+
+Example:
+```go
+Mac: &mac.Options{
+ TitleBar: mac.TitleBarHiddenInset(),
+}
+```
+
+Click [here](https://github.com/lukakerr/NSWindowStyles) for some inspiration on customising the titlebar.
+
+#### Appearance type
+
+You can specify the application's [appearance](https://developer.apple.com/documentation/appkit/nsappearance?language=objc).
+
+| Value | Description |
+| --------------- | ------------------ |
+| DefaultAppearance | DefaultAppearance uses the default system value |
+| NSAppearanceNameAqua | The standard light system appearance |
+| NSAppearanceNameDarkAqua | The standard dark system appearance |
+| NSAppearanceNameVibrantLight | The light vibrant appearance |
+| NSAppearanceNameAccessibilityHighContrastAqua | A high-contrast version of the standard light system appearance |
+| NSAppearanceNameAccessibilityHighContrastDarkAqua | A high-contrast version of the standard dark system appearance |
+| NSAppearanceNameAccessibilityHighContrastVibrantLight | A high-contrast version of the light vibrant appearance |
+| NSAppearanceNameAccessibilityHighContrastVibrantDark | A high-contrast version of the dark vibrant appearance |
+
+Example:
+```go
+Mac: &mac.Options{
+ Appearance: mac.NSAppearanceNameDarkAqua,
+}
+```
+
+#### About struct
+
+```go
+type AboutInfo struct {
+ Title string
+ Message string
+ Icon []byte
+}
+```
+If these settings are provided, an "About" menu item will appear in the app menu (when using the `AppMenu` role).
+Given this configuration:
+```go
+//go:embed build/appicon.png
+var icon []byte
+
+func main() {
+ err := wails.Run(&options.App{
+ ...
+ Mac: &mac.Options{
+ About: &mac.AboutInfo{
+ Title: "My Application",
+ Message: "Β© 2021 Me",
+ Icon: icon,
+ },
+ },
+ })
+```
+The "About" menu item will appear in the app menu:
+
+
+
+
+
+
+
+
+