neil/silverbullet
1
0
Fork 0
Code

Website content updates

Browse Source
This commit is contained in:
Zef Hemel 2023-11-15 09:31:52 +01:00
parent b4ab56c712
commit 4acfd96011
10 changed files with 260 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
web/components/widget_sandbox_iframe.ts
View File

@ -16,20 +16,17 @@ type PreloadedIFrame = {
};
const iframePool = new Set<PreloadedIFrame>();
const desiredPoolSize = 5;
const gcInterval = 5000;
const desiredPoolSize = 3;
function populateIFramePool() {
while (iframePool.size < desiredPoolSize) {
iframePool.add(prepareSandboxIFrame());
}
}
updatePool();
populateIFramePool();
setInterval(() => {
function updatePool(exclude?: PreloadedIFrame) {
let availableFrames = 0;
// Iterate over all iframes
for (const preloadedIframe of iframePool) {
if (preloadedIframe === exclude) {
continue;
}
if (
// Is this iframe in use, but has it since been removed from the DOM?
preloadedIframe.used && !document.body.contains(preloadedIframe.iframe)
@ -38,18 +35,28 @@ setInterval(() => {
console.log("Garbage collecting iframe", preloadedIframe);
iframePool.delete(preloadedIframe);
}
if (!preloadedIframe.used) {
availableFrames++;
}
}
populateIFramePool();
}, gcInterval);
// And after, add more iframes if needed
for (let i = 0; i < desiredPoolSize - availableFrames; i++) {
iframePool.add(prepareSandboxIFrame());
}
}
export function prepareSandboxIFrame(): PreloadedIFrame {
console.log("Preloading iframe");
const iframe = document.createElement("iframe");
// Empty page with current origin. Handled this differently before, but "dock apps" in Safari (PWA implementation) seem to have various restrictions
// This one works in all browsers, although it's probably less secure
iframe.src = "about:blank";
const ready = new Promise<void>((resolve) => {
iframe.onload = () => {
iframe.contentDocument!.write(panelHtml);
// Now ready to use
resolve();
};
});
@ -65,10 +72,12 @@ function claimIFrame(): PreloadedIFrame {
if (!preloadedIframe.used) {
console.log("Took iframe from pool");
preloadedIframe.used = true;
updatePool(preloadedIframe);
return preloadedIframe;
}
}
// Nothing available in the pool, let's spin up a new one and add it to the pool
console.log("Yeah this shouldn't happen");
const newPreloadedIFrame = prepareSandboxIFrame();
newPreloadedIFrame.used = true;
iframePool.add(newPreloadedIFrame);

3
website/Authelia.md
View File

@ -1,4 +1,5 @@
# How to setup SilverBullet with Authelia
How to setup SilverBullet with Authelia
In order for SilverBullet to work as intended, some files will need to be excluded from your authentication method of choice. These files need to always be accessible, for example for offline or [[PWA]] support.
The files are the following:

118
website/Install.md
View File

@ -1,115 +1,5 @@
Installing SilverBullet as a (local) web server is pretty straightforward.
There’s a progressive path in how people tend to install and deploy SilverBullet. Generally, it’s best to try it out on your local machine first. Play around a bit, see if it’s for you. Once you’re hooked, you may want to spend a little bit more time and host SilverBullet on a server in your local network or on the public Internet. SilverBullet is not currently available as a SaaS product, so you’ll have to install and run it yourself.
The idea is simple: you run the web server (instructions below), point your browser at it, and _go, go, go_! You can access the URL via your desktop browser but also a mobile one. You could even go _full-on YOLO_ (that’s a technical term), and install it on a public cloud server somewhere and access it that way (be sure to at least enable authentication and put SSL on top of it, though).
You have two options to install and run SilverBullet as a server:
1. Installation via Deno on your host system
2. Running it with Docker
In either case, check the notes [[@tls|on using TLS]].
## Installation via Deno
$deno
This consists of two steps (unless Deno is already installed — in which case we’re down to one):
1. [Install Deno](https://deno.land/manual/getting_started/installation)
2. Installing SilverBullet itself (steps below)
### Install SilverBullet
With Deno installed, run:
```shell
deno install -f --name silverbullet --unstable -A https://get.silverbullet.md
```
This will give you (and when you use `silverbullet upgrade`) the latest stable release. If you prefer to live on the bleeding edge, you can install using the following command instead:
```shell
deno install -f --name silverbullet --unstable -A https://silverbullet.md/silverbullet.js
```
This will install `silverbullet` into your `~/.deno/bin` folder (which should already be in your `$PATH` if you followed the Deno install instructions).
To run SilverBullet, create a folder for your pages (it can be empty or be an existing folder with `.md` files) and run the following command in your terminal:
```shell
silverbullet <pages-path>
```
By default, SilverBullet will bind to port `3000`; to use a different port, use the `-p` flag.
For security reasons, by default, SilverBullet only allows connections via `localhost` (or `127.0.0.1`). To also allow connections from the network, pass a `-L 0.0.0.0` flag (0.0.0.0 for all connections, or insert a specific address to limit the host), ideally combined with `--user username:password` to add BasicAuth password protection.
Once downloaded and booted, SilverBullet will print out a URL to open SB in your browser. Please make note of [[@tls|the use of HTTPs]].
## Upgrading SilverBullet
SilverBullet is regularly updated. To get the latest and greatest, simply run:
```shell
silverbullet upgrade
```
And restart SilverBullet. You should be good to go.
## Installing SilverBullet with Docker
$docker
There is a [docker image on docker hub](https://hub.docker.com/r/zefhemel/silverbullet). The image comes in two flavors:
* 64-bit Intel
* 64-bit ARM (e.g. for Raspberry Pis and Macs)
There is no 32-bit version of Deno, and therefore we cannot offer a 32-bit version of SilverBullet either.
To use the docker container, first create a volume to keep your space (markdown) files:
```shell
docker volume create myspace
```
Then, run the container, e.g., as follows:
```shell
docker run -p 3000:3000 -v myspace:/space -d zefhemel/silverbullet
```
The `zefhemel/silverbullet` image will give you the latest released version. This is equivalent to `zefhemel/silverbullet:latest`. If you prefer, you can also pin to a specific release, e.g. `zefhemel/silverbullet:0.3.7`. If you prefer to live on the bleeding edge, you can use the `zefhemel/silverbullet:edge` image, which is updated on every commit to the `main` brain.
To configure various things such as authentication, use [[@env|environment variables]], e.g. to enable single-user auth:
```shell
docker run -p 3000:3000 -v myspace:/space -d -e SB_USER=me:letmein zefhemel/silverbullet
```
To build your own version of the docker image, run `./scripts/build_docker.sh`.
To upgrade, simply pull the latest docker image and start the new container.
```shell
docker pull zefhemel/silverbullet
```
## Exposing SilverBullet to your network/Internet
$tls
Running SilverBullet on your machine is cool, but you likely want to access it from elsewhere as well (other machines on your network, your mobile device), perhaps even from outside your home. For this you either need to use a VPN, or expose SB to the public Internet. In either scenario, be sure to use [[Authentication]].
To expose your SilverBullet instance to the Internet, you have a few options:
* [[Deployments/ngrok]]: the easiest solution to exposing your _locally running_ SilverBullet to the Internet
* [[Deployments/Caddy]]: the easiest solution to expose SilverBullet running on a publicly accessible server to the Internet (but local network as well using Tailscale)
If you access SilverBullet via plain HTTP (outside of localhost) everything _should_ still mostly work, except offline mode.
## Environment variables
$env
You can configure SB with environment variables instead of flags as well. The following environment variables are supported:
* `SB_USER`: Sets single-user credentials (like `--user`), e.g. `SB_USER=pete:1234`
* `SB_HOSTNAME`: Set to the hostname to bind to (defaults to `127.0.0.0`, set to `0.0.0.0` to accept outside connections)
* `SB_PORT`: Sets the port to listen to, e.g. `SB_PORT=1234`
* `SB_FOLDER`: Sets the folder to expose, e.g. `SB_FOLDER=/space`
* `SB_AUTH`: Loads an [[Authentication]] database from a (JSON encoded) string, e.g. `SB_AUTH=$(cat /path/to/.auth.json)`
* `SB_SYNC_ONLY`: Runs the server in a "dumb" space store only mode (not indexing content or keeping other state), e.g. `SB_SYNC_ONLY=1`
## Using Authelia
You need to adjust a few configuration options in [[Authelia]] in order for SilverBullet to work as intended.
Instructions:
* [[Install/Local]]: how to set up SilverBullet on your local machine
* [[Install/Network and Internet]]: how to set up SilverBullet and expose it to your network or via the Internet

106
website/Install/Local.md Normal file
View File

@ -0,0 +1,106 @@
Let’s start with the simplest, local machine setup:
## Local machine setup
Installing SilverBullet as a (local) web server is pretty straightforward, if you’re comfortable with the terminal, at least.
The setup is simple: in a terminal run the silverbullet server process on your machine, then connect to it locally from your browser.
You have two options here:
1. Installation via [Deno](https://deno.com/) (the awesome JavaScript runtime)
2. Installation via [Docker](https://www.docker.com/) (the awesome container runtime)
### Installation via Deno
$deno
This consists of two steps (unless Deno is already installed — in which case we’re down to one):
1. [Install Deno](https://deno.land/manual/getting_started/installation)
2. Install SilverBullet itself (steps below)
After having installed Deno ([instructions on its website](https://docs.deno.com/runtime/manual/getting_started/installation)) run:
```shell
deno install -f --name silverbullet --unstable -A https://get.silverbullet.md
```
You only have to do this once.
This will give you (and when you use `silverbullet upgrade`) the latest stable release. If you prefer to live on the bleeding edge, you can install using the following command instead:
```shell
deno install -f --name silverbullet --unstable -A https://silverbullet.md/silverbullet.js
```
Either command will install `silverbullet` into your `~/.deno/bin` folder (which should already be in your `$PATH` if you followed the Deno install instructions).
To run SilverBullet, create a folder for your pages (it can be empty or be an existing folder with `.md` files) and run the following command in your terminal:
```shell
silverbullet <pages-path>
```
By default, SilverBullet will bind to port `3000`; to use a different port, use the `-p` flag.
For security reasons, by default, SilverBullet only allows connections via `localhost` (or `127.0.0.1`). To also allow connections from the network, pass a `-L 0.0.0.0` flag (0.0.0.0 for all connections, or insert a specific address to limit the host), ideally combined with `--user username:password` to add simple password protection.
Once downloaded and booted, SilverBullet will print out a URL to open SB in your browser.
#### Upgrading SilverBullet
SilverBullet is regularly updated. To get the latest and greatest, simply run:
```shell
silverbullet upgrade
```
And restart SilverBullet. You should be good to go.
### Installing SilverBullet with Docker
$docker
There is a [docker image on docker hub](https://hub.docker.com/r/zefhemel/silverbullet). The image comes in two flavors:
* 64-bit Intel
* 64-bit ARM (e.g. for Raspberry Pis and Macs)
There is no 32-bit version of Deno, and therefore we cannot offer a 32-bit version of SilverBullet either.
To use the docker container, first create a volume to keep your space (markdown) files:
```shell
docker volume create myspace
```
Then, run the container, e.g., as follows:
```shell
docker run -p 3000:3000 -v myspace:/space -d zefhemel/silverbullet
```
The `zefhemel/silverbullet` image will give you the latest released version. This is equivalent to `zefhemel/silverbullet:latest`. If you prefer, you can also pin to a specific release, e.g. `zefhemel/silverbullet:0.5.5`. If you prefer to live on the bleeding edge, you can use the `zefhemel/silverbullet:edge` image, which is updated on every commit to the `main` brain.
To configure various things such as authentication, use [[@env|environment variables]], e.g. to enable single-user auth:
```shell
docker run -p 3000:3000 -v myspace:/space -d -e SB_USER=me:letmein zefhemel/silverbullet
```
To build your own version of the docker image, run `./scripts/build_docker.sh`.
To upgrade, simply pull the latest docker image and start a new container.
```shell
docker pull zefhemel/silverbullet
```
## Configuration
SilverBullet is partially configured via flags (run it with `--help`) or alternatively via environment variables and partially via a [[SETTINGS]] page in your space.
## Environment variables
$env
You can configure SB with environment variables instead of flags, which is probably what you want to do in a docker setup. The following environment variables are supported:
* `SB_USER`: Sets single-user credentials (like `--user`), e.g. `SB_USER=pete:1234`
* `SB_HOSTNAME`: Set to the hostname to bind to (defaults to `127.0.0.0`, set to `0.0.0.0` to accept outside connections)
* `SB_PORT`: Sets the port to listen to, e.g. `SB_PORT=1234`
* `SB_FOLDER`: Sets the folder to expose, e.g. `SB_FOLDER=/space`
* `SB_AUTH`: Loads an [[Authentication]] database from a (JSON encoded) string, e.g. `SB_AUTH=$(cat /path/to/.auth.json)`
* `SB_SYNC_ONLY`: Runs the server in a "dumb" space store only mode (not indexing content or keeping other state), e.g. `SB_SYNC_ONLY=1`

17
website/Install/Network and Internet.md Normal file
View File

@ -0,0 +1,17 @@
Running SilverBullet [[Install/Local|locally]] on your machine is cool, but you likely want to access it from elsewhere as well (other machines on your network, your mobile device), perhaps even from outside your home. For this you either need to use a VPN, or expose SB to the public Internet via _HTTPS_.
In either scenario, be sure to enable some sort of [[Authentication]].
There’s two parts to this process:
1. Run the SilverBullet server itself somewhere, following the [[Install/Local]] instructions
2. Exposing this server to the network/Internet
In all scenarios (that are not [[Install/Local]]) you _have_ to access SilverBullet via HTTPS otherwise certain features (such offline-support) won’t work.
People have found various simple to more complex ways of achieving this.
* Using [[Deployments/ngrok]] is likely the easiest solution to exposing your _locally running_ SilverBullet to the Internet. Note that “locally running” can mean your own local machine, but can still refer to running it on a server in your network (like a Raspberry Pi).
* [[Deployments/Caddy]]: the easiest solution to expose SilverBullet running on a publicly accessible server to the Internet (but local network as well using Tailscale)
* [[Authelia]] setup hints
* [[Guide/Deployment/Cloudflare and Portainer]]

9
website/Manual.md
View File

@ -1,4 +1,9 @@
A full manual is still missing, but this is an attempt to give pointers on topics you may be interested in.
Welcome to wonderful world of SilverBullet. The goal of this manual is to give you a broad sense of how to use this tool, and what it’s capable of. However, its full capabilities are yet to be discovered. Every day people are finding new and creative ways to use the various SilverBullet features in ways that nobody previously thought of. Perhaps you will be one of those people.
That is unlikely to happen unless you understand some of the basics, however. So let’s start tjere.
> **warning** Warning
> This manual is **very** much a work in progress
## Keeping up-to-date
* [[CHANGELOG]]: what’s new in SilverBullet
@ -10,7 +15,7 @@ A full manual is still missing, but this is an attempt to give pointers on topic
* [[Authelia]]: configuring SilverBullet with [Authelia](https://www.authelia.com/) authentication.
* [[Guide/Deployment/Cloudflare and Portainer]]: configuring SilverBullet with a Cloudflare tunnel, portainer and optionall Cloudflare zero trust authentication.
## Usage
## Use
* [[Markdown]]
* [[Markdown/Syntax Highlighting]]
* [[Markdown/Code Widgets]]

22
website/Markdown.md
View File

@ -1,18 +1,10 @@
Markdown is a plain text formatting system [originally developed by John Gruber](https://daringfireball.net/projects/markdown/). It has since been standardized into [CommonMark](https://commonmark.org/), which is what SilverBullet uses (with some extensions).
Markdown is a plain text formatting system [originally developed by John Gruber](https://daringfireball.net/projects/markdown/). It has since been standardized into [CommonMark](https://commonmark.org/), which is what SilverBullet uses (with [[Markdown/Extensions]]). While a bit more technical than [WYSIWYG](https://pl.wikipedia.org/wiki/WYSIWYG)-style editing (like MS Word), the nice thing about markdown is that is a (relatively) easy to implement standard and you can read files even without special tools (like SilverBullet). This means that even if you switch tools, you’ll always have access to the content. It also means that you can use multiple tools at the same time to edit these files. You don’t have to use SilverBullet exclusively.
If you’re not yet familiar with Markdown [here is a good guide to get you started](https://www.markdownguide.org/basic-syntax/).
There is a bit of a caveat here: Markdown is limited in certain ways, and various tools using markdown as the underlying file format (like SilverBullet) need features that are not directly supported by markdown. As a result, different tools introduce extensions to markdown that are not standard nor interoperable. While in some cases these tools converge on particular pieces of syntax (such as the non-standard `[[page link]]` syntax), some level of divergence in the markdown that each tool supports is unavoidable. SilverBullet is complicit in this as well, it adds a few extensions that are not widely supported, and assigns new meaning certain markdown features to implement novel features. In its defense, all these features are optional. If you want to just write plain markdown, you can.
We mentioned markdown _extensions_, here are the ones currently supported:
See [[Markdown/Extensions]] for more details on these SilverBullet-specific extensions.
* [[Frontmatter]]
* Double-bracketed wiki links: `[[link to page]]`, optionally with aliases `[[link to page|alias]]`.
* Hashtags, e.g. `#mytag`.
* Command link syntax: `{[Stats: Show]}` rendered into a clickable button {[Stats: Show]}.
* [[Markdown/Code Widgets]]
* [[Anchors]]
* [Tables](https://www.markdownguide.org/extended-syntax/#tables)
* [Fenced code blocks](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks)
* [Task lists](https://www.markdownguide.org/extended-syntax/#task-lists)
* [Highlight](https://www.markdownguide.org/extended-syntax/#highlight)
* [Automatic URL linking](https://www.markdownguide.org/extended-syntax/#automatic-url-linking)
* Custom markdown extensions provided by plugs
More about markdown:
* [[Markdown/Basics]]: learn some the markdown basics
* [[Markdown/Extensions]]: learn about SilverBullet’s set of markdown extensions

59
website/Markdown/Basics.md Normal file
View File

@ -0,0 +1,59 @@
The idea of markdown is that you write plain text with some additional markup that even without further processing (like rendering it to HTML, or [[Live Preview]]) you could just read and understand. It was inspired by conventions used in plain-text e-mails, before e-mail supported rich formatting.
### Basic markup
So to write markdown, you just write text. But then to emphasize something you can add `_underscores_` around a phrase to make look _italic_, or `**asterisks**` to make it **bold**. You can also use `~~tildes~~` for ~~strikethrough~~ and `==double equals==` for ==highlighting==.
### Links
To add external links you use the `[site link](https://silverbullet.md)` syntax, which will appear as [site link](https://silverbullet.md). If you want to link to other pages in your space you use the `[[wiki link syntax]]`, e.g. [[SilverBullet]]. To change the link text you can use the `[[SilverBullet|best PKM evah]]` syntax: [[SilverBullet|best PKM evah]].
## Lists and tasks
You can create three types of lists:
Unordered lists are created by prefixing a line with `*` or `-`. For instance:
* This is an unordered list
* And this is a second item
Since this tool is called SilverBullet, we prefer you to use the `*` bullet (which will even appear in _silver_ — clever huh?).
Ordered lists are created by simply putting a number follow by a period at the beginning of a line:
1. This is the first item
2. This is the second item
SilverBullet also supports a variant of the unordered list item to define task. Tasks are defined using the `* [ ] Task name` syntax:
* [ ] This is a task
* [ ] And this is another
When you click the checkbox, it will toggle its state and replace the ` ` inside the box with `x`. SilverBullet also supports custom task statuses by putting text in between `[` and `]`. When you click on such custom task states, it will cycle through all the task states it’s seen in your space:
* [IN PROGRESS] This task is in progress
* [DONE] This task is done
* [TO DO] This task is still to be done
## Headers
Markdown supports various levels of headings, which generally are created by prefixing a line with one or more `#`. The more `#`‘s the deeper the header nesting.
## Quotes
You can use block quotes by prefixing lines with `>`:
> “If you don’t know where you’re going, you may not get there.”
> — Yogi Berra
## Code
For the programmers among us, there’s three ways to mark up code. If you want to write some code inline, you can use backticks: `this is code`. For long code snippets you can either use a four-space indent:
This is code
And another line
Or (preferably) the triple-back tick notation, which also allows you to (optionally) specify a coding language:
```javascript
function hello() {
return "sup";
}
```
SilverBullet supports [[Markdown/Syntax Highlighting]] for many languages out of the box.

16
website/Markdown/Extensions.md Normal file
View File

@ -0,0 +1,16 @@
In addition to supporting [[Markdown/Basics|markdown basics]] as standardized by [CommonMark](https://commonmark.org/), SilverBullet relies on the following extensions:
* Double-bracketed wiki links: `[[link to page]]`, optionally with aliases `[[link to page|alias]]`.
* [[Frontmatter]] and [[Attributes]]
* [Fenced code blocks](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks), and in addition, assigning new meanings to specific fenced code block languages:
* Generically via [[Markdown/Code Widgets]]
* [[Live Queries]]
* [[Live Templates]]
* [[Anchors]]
* Hashtags, e.g. `#mytag`.
* Command link syntax: `{[Stats: Show]}` rendered into a clickable button {[Stats: Show]}.
* [Tables](https://www.markdownguide.org/extended-syntax/#tables)
* [Task lists](https://www.markdownguide.org/extended-syntax/#task-lists)
* [Highlight](https://www.markdownguide.org/extended-syntax/#highlight)
* [Automatic URL linking](https://www.markdownguide.org/extended-syntax/#automatic-url-linking)
* Any addition custom markdown extensions provided by [[🔌 Plugs]]

30
website/SilverBullet.md
View File

@ -1,12 +1,23 @@
SilverBullet is an extensible, [open source](https://github.com/silverbulletmd/silverbullet), **personal knowledge management** system. Indeed, that’s fancy talk for “a note-taking app with links.” However, SilverBullet goes _a bit_ beyond just that.
SilverBullet aims to be your **workshop for the mind**: a creative environment where you collect, create and expand your personal knowledge in primarily textual form, while also letting you constantly evolve the tools you use to do so.
While you _can_ use SilverBullet as a simple note taking application that stores notes in plain markdown files on disk, it becomes truly powerful in the hands of more technical power users. By leveraging [[Metadata]] annotations, its [[Objects]] infrastructure, [[Live Queries]] and [[Live Templates]], SilverBullet becomes a powerful _end-user programming tool_, enabling you to quickly develop various types of ad-hoc knowledge applications.
SilverBullet is implemented as an open-source, self-hosted, offline-capable web application.
You’ve been told there is _no such thing_ as a [silver bullet](https://en.wikipedia.org/wiki/Silver_bullet). You were told wrong.
Before we get to the nitty gritty, some _quick links_ for the impatient reader: [[Install]], [[Manual]], [[CHANGELOG]], [Roadmap](https://github.com/orgs/silverbulletmd/projects/2/views/1), [Issues](https://github.com/silverbulletmd/silverbullet/issues), [Discussions](https://github.com/silverbulletmd/silverbullet/discussions), [Mastodon](https://fosstodon.org/@silverbulletmd), [Discord](https://discord.gg/EvXbFucTxn), [Docker Hub](https://hub.docker.com/r/zefhemel/silverbullet).
Now that we got that out of the way let’s have a look at some of SilverBullet’s features.
## Quick links
* [[Install]]: how to install and deploy SilverBullet
* [[Manual]]: the beginnings of a user manual
* [[CHANGELOG]]: SilverBullet is in very active development, so things change rapidly. Watch this to see what’s new and changed.
* [Roadmap](https://github.com/orgs/silverbulletmd/projects/2/views/1): currently planned features and priorities
* [Issues](https://github.com/silverbulletmd/silverbullet/issues): if you have ideas, or find bugs, please report them
* [Discussions](https://github.com/silverbulletmd/silverbullet/discussions)
* [Mastodon](https://fosstodon.org/@silverbulletmd): Follow SilverBullet development on [Mastodon](https://joinmastodon.org/)
* [Discord](https://discord.gg/EvXbFucTxn): For more real-time support and discussion, join our Discord!
## Features
SilverBullet...
* Runs in any modern browser (including on mobile) as a [[PWA]] in two [[Client Modes]] (_online_ and _synced_ mode), where the _synced mode_ enables **100% offline operation**, keeping a copy of content in the browser, syncing back to the server when a network connection is available.
* Provides an enjoyable [[Markdown]] writing experience with a clean UI, rendering text using [[Live Preview|live preview]], further **reducing visual noise** while still providing direct access to the underlying markdown syntax.
* Supports wiki-style **page linking** using the `[[page link]]` syntax. Incoming links are indexed and appear as “Linked Mentions” at the bottom of the pages linked to thereby providing _bi-directional linking_.
@ -19,7 +30,7 @@ Now that we got that out of the way let’s have a look at some of SilverBullet
* **Self-hosted**: you own your data. All content is stored as plain files in a folder on disk. Back up, sync, edit, publish, script with any additional tools you like.
* SilverBullet is [open source, MIT licensed](https://github.com/silverbulletmd/silverbullet) software.
To get a good feel of what SilverBullet is capable of, have a look at this introduction video.
To get a good feel of what SilverBullet is capable of, have a look at this (slightly out of date) introduction video.
```embed
url: https://youtu.be/VemS-cqAD5k
@ -70,9 +81,10 @@ name: SilverBullet
rating: 5
```
But where things get _really_ interesting is when using features like [[Live Queries]] that allow you to query all types of [[Objects]] indexed based on the pages in your space.
## Going deeper
Where things get _really_ interesting is when using features like [[Live Queries]] that allow you to query all types of [[Objects]] indexed based on the pages in your space.
Let’s explore this with a meta example of using this for this very website. All pages in this space that represent a plug are tagged with the `#plug` tag. Now, if we would want to render a list of all plugs in one place using the [[template/plug]] template, we can simply do this:
Let’s explore this with a meta example of using this functionality for this very website. All pages in this space that represent a [[🔌 Plugs|plug]] are tagged with the `#plug` tag. Now, if we would want to render a list of all plugs in one place using the [[template/plug]] template, we can simply do this:
```query
plug render [[template/plug]]
@ -85,10 +97,10 @@ For instance, here’s a list of all outgoing page links from this page:
```query
link where page = "{{@page.name}}" select toPage as name render [[template/page]]
```
The sky is the limit.
The sky is the limit. See [[Objects]] and [[Live Queries]] for more information.
## Install SilverBullet
Has your mind been sufficiently blown to commit to an install? Took you long enough, alright then. Please proceed to the [[Install]] and enjoy!
Has your mind been sufficiently blown to commit to an install? Took you long enough, alright then. Please proceed to [[Install]] and enjoy!
## Where to go from here
Have a lock at our work-in-progress [[Manual]].