commit ce12f1945b99196491643045416fdc7d7dc8c162 · nonbinary.computer/weaver

+39 -8

crates/weaver-renderer/src/css.rs

··· 1 1 use crate::theme::Theme; 2 2 use miette::IntoDiagnostic; 3 - use syntect::highlighting::ThemeSet; 3 + use syntect::highlighting::{Theme as SyntectTheme, ThemeSet}; 4 4 use syntect::html::{ClassStyle, css_for_theme_with_class_style}; 5 5 use syntect::parsing::SyntaxSet; 6 + use std::io::Cursor; 7 + 8 + // Embed rose-pine themes at compile time 9 + const ROSE_PINE_THEME: &str = include_str!("../themes/rose-pine.tmTheme"); 10 + const ROSE_PINE_DAWN_THEME: &str = include_str!("../themes/rose-pine-dawn.tmTheme"); 6 11 7 12 pub fn generate_base_css(theme: &Theme) -> String { 8 13 format!( ··· 179 184 } 180 185 181 186 pub fn generate_syntax_css( 182 - syntect_theme_name: &str, 187 + theme: &Theme, 183 188 _syntax_set: &SyntaxSet, 184 189 ) -> miette::Result<String> { 185 - let theme_set = ThemeSet::load_defaults(); 186 - let theme = theme_set 187 - .themes 188 - .get(syntect_theme_name) 189 - .ok_or_else(|| miette::miette!("Theme '{}' not found", syntect_theme_name))?; 190 + let syntect_theme = if let Some(custom_path) = &theme.custom_syntect_theme_path { 191 + // Load custom theme from file 192 + ThemeSet::get_theme(custom_path) 193 + .into_diagnostic() 194 + .map_err(|e| miette::miette!("Failed to load custom theme from {:?}: {}", custom_path, e))? 195 + } else { 196 + // Check for embedded themes first 197 + match theme.syntect_theme_name.as_str() { 198 + "rose-pine" => { 199 + let mut cursor = Cursor::new(ROSE_PINE_THEME.as_bytes()); 200 + ThemeSet::load_from_reader(&mut cursor) 201 + .into_diagnostic() 202 + .map_err(|e| miette::miette!("Failed to load embedded rose-pine theme: {}", e))? 203 + } 204 + "rose-pine-dawn" => { 205 + let mut cursor = Cursor::new(ROSE_PINE_DAWN_THEME.as_bytes()); 206 + ThemeSet::load_from_reader(&mut cursor) 207 + .into_diagnostic() 208 + .map_err(|e| miette::miette!("Failed to load embedded rose-pine-dawn theme: {}", e))? 209 + } 210 + _ => { 211 + // Fall back to syntect's built-in themes 212 + let theme_set = ThemeSet::load_defaults(); 213 + theme_set 214 + .themes 215 + .get(theme.syntect_theme_name.as_str()) 216 + .ok_or_else(|| miette::miette!("Theme '{}' not found in defaults", theme.syntect_theme_name))? 217 + .clone() 218 + } 219 + } 220 + }; 190 221 191 222 let css = css_for_theme_with_class_style( 192 - theme, 223 + &syntect_theme, 193 224 ClassStyle::SpacedPrefixed { 194 225 prefix: crate::code_pretty::CSS_PREFIX, 195 226 },

+4 -4

crates/weaver-renderer/src/snapshots/weaver_renderer__static_site__tests__code_block_rendering.snap

··· 2 2 source: crates/weaver-renderer/src/static_site.rs 3 3 expression: output 4 4 --- 5 - <pre><code class="language-rust">fn main() { 6 - println!("Hello"); 7 - } 8 - </code></pre> 5 + <pre><code class="language-Rust">fn main() { 6 + println!("Hello"); 7 + } 8 + </code></pre>

+200 -7

crates/weaver-renderer/src/static_site.rs

··· 11 11 12 12 use crate::{ 13 13 ContextIterator, NotebookProcessor, 14 - static_site::{context::StaticSiteContext, writer::StaticPageWriter}, 14 + static_site::{ 15 + context::StaticSiteContext, 16 + document::{CssMode, write_document_footer, write_document_head}, 17 + writer::StaticPageWriter, 18 + }, 15 19 utils::flatten_dir_to_just_one_parent, 16 20 walker::{WalkOptions, vault_contents}, 17 21 }; ··· 131 135 } 132 136 self.context.destination.clone() 133 137 }; 134 - return write_page(self.context.clone(), &self.context.start_at, dest).await; 138 + // Use standalone writer for single file (inline CSS) 139 + return write_page_standalone(self.context.clone(), &self.context.start_at, dest).await; 135 140 } 136 141 137 142 if !self.context.destination.exists() { ··· 140 145 self.context.destination.display() 141 146 )); 142 147 } 148 + 149 + // Generate CSS files for multi-file mode 150 + self.generate_css_files().await?; 143 151 144 152 let mut writers = 145 153 Vec::with_capacity(self.context.dir_contents.clone().unwrap_or_default().len()); ··· 161 169 .strip_prefix(context.start_at.clone()) 162 170 .expect("file should always be nested under root") 163 171 .to_path_buf(); 172 + 173 + // Check if this is a markdown file 174 + let is_markdown = file.extension() 175 + .and_then(|ext| ext.to_str()) 176 + .map(|ext| ext == "md" || ext == "markdown") 177 + .unwrap_or(false); 178 + 179 + if !is_markdown { 180 + // Copy non-markdown files directly 181 + let output_path = if context 182 + .options 183 + .contains(StaticSiteOptions::FLATTEN_STRUCTURE) 184 + { 185 + let path_str = relative_path.to_string_lossy(); 186 + let (parent, fname) = flatten_dir_to_just_one_parent(&path_str); 187 + let parent = if parent.is_empty() { "entry" } else { parent }; 188 + context 189 + .destination 190 + .join(String::from(parent)) 191 + .join(String::from(fname)) 192 + } else { 193 + context.destination.join(relative_path.clone()) 194 + }; 195 + 196 + // Create parent directory if needed 197 + if let Some(parent) = output_path.parent() { 198 + tokio::fs::create_dir_all(parent).await.into_diagnostic()?; 199 + } 200 + 201 + tokio::fs::copy(&file, &output_path).await.into_diagnostic()?; 202 + return Ok(()); 203 + } 204 + 205 + // Process markdown files 206 + // Check if this is the designated index file 207 + if let Some(index) = &context.index_file { 208 + if &relative_path == index { 209 + let output_path = context.destination.join("index.html"); 210 + return write_page(context.clone(), file, output_path).await; 211 + } 212 + } 213 + 164 214 if context 165 215 .options 166 216 .contains(StaticSiteOptions::FLATTEN_STRUCTURE) 167 217 { 168 218 let path_str = relative_path.to_string_lossy(); 169 - let (parent, file) = flatten_dir_to_just_one_parent(&path_str); 219 + let (parent, fname) = flatten_dir_to_just_one_parent(&path_str); 220 + let parent = if parent.is_empty() { "entry" } else { parent }; 170 221 let output_path = context 171 222 .destination 172 223 .join(String::from(parent)) 173 - .join(String::from(file)); 224 + .join(String::from(fname)); 174 225 175 - write_page(context.clone(), relative_path, output_path).await?; 226 + write_page(context.clone(), file.clone(), output_path).await?; 176 227 } else { 177 228 let output_path = context.destination.join(relative_path.clone()); 178 229 179 - write_page(context.clone(), relative_path, output_path).await?; 230 + write_page(context.clone(), file.clone(), output_path).await?; 180 231 } 181 232 Ok::<(), miette::Report>(()) 182 233 })); ··· 187 238 for fut in n0_future::join_all(writers).await.into_iter() { 188 239 fut.into_diagnostic()??; 189 240 } 241 + 242 + // Generate default index if requested and no custom index specified 243 + if self 244 + .context 245 + .options 246 + .contains(StaticSiteOptions::CREATE_INDEX) 247 + && self.context.index_file.is_none() 248 + { 249 + self.generate_default_index().await?; 250 + } 251 + 252 + Ok(()) 253 + } 254 + 255 + async fn generate_css_files(&self) -> Result<(), miette::Report> { 256 + use crate::css::{generate_base_css, generate_syntax_css}; 257 + use crate::theme::Theme; 258 + 259 + let css_dir = self.context.destination.join("css"); 260 + tokio::fs::create_dir_all(&css_dir) 261 + .await 262 + .into_diagnostic()?; 263 + 264 + let default_theme = Theme::default(); 265 + let theme = self.context.theme.as_deref().unwrap_or(&default_theme); 266 + 267 + // Write base.css 268 + let base_css = generate_base_css(theme); 269 + tokio::fs::write(css_dir.join("base.css"), base_css) 270 + .await 271 + .into_diagnostic()?; 272 + 273 + // Write syntax.css 274 + let syntax_css = generate_syntax_css(theme, &self.context.syntax_set)?; 275 + tokio::fs::write(css_dir.join("syntax.css"), syntax_css) 276 + .await 277 + .into_diagnostic()?; 278 + 279 + Ok(()) 280 + } 281 + 282 + async fn generate_default_index(&self) -> Result<(), miette::Report> { 283 + let index_path = self.context.destination.join("index.html"); 284 + let mut index_file = crate::utils::create_file(&index_path).await?; 285 + 286 + // Write head 287 + write_document_head(&self.context, &mut index_file, CssMode::Linked, &index_path).await?; 288 + 289 + // Write title and list 290 + index_file 291 + .write_all(b"<h1>Index</h1>\n<ul>\n") 292 + .await 293 + .into_diagnostic()?; 294 + 295 + // List all files 296 + if let Some(contents) = &self.context.dir_contents { 297 + for file in contents.iter() { 298 + if let Ok(relative) = file.strip_prefix(&self.context.start_at) { 299 + let display_name = relative.to_string_lossy(); 300 + let link = if self 301 + .context 302 + .options 303 + .contains(StaticSiteOptions::FLATTEN_STRUCTURE) 304 + { 305 + let (parent, fname) = flatten_dir_to_just_one_parent(&display_name); 306 + // Change extension to .html 307 + let fname_html = 308 + PathBuf::from(fname.as_ref() as &str).with_extension("html"); 309 + let fname_html_str = fname_html.to_string_lossy(); 310 + if !parent.is_empty() { 311 + format!("./{}/{}", parent, fname_html_str) 312 + } else { 313 + format!("./entry/{}", fname_html_str) 314 + } 315 + } else { 316 + // Change extension to .html 317 + let html_path = 318 + PathBuf::from(display_name.as_ref() as &str).with_extension("html"); 319 + format!("./{}", html_path.to_string_lossy()) 320 + }; 321 + 322 + index_file 323 + .write_all( 324 + format!(" <li><a href=\"{}\">{}</a></li>\n", link, display_name) 325 + .as_bytes(), 326 + ) 327 + .await 328 + .into_diagnostic()?; 329 + } 330 + } 331 + } 332 + 333 + index_file.write_all(b"</ul>\n").await.into_diagnostic()?; 334 + 335 + // Write footer 336 + write_document_footer(&mut index_file).await?; 337 + 190 338 Ok(()) 191 339 } 192 340 } ··· 227 375 let contents = tokio::fs::read_to_string(&input_path) 228 376 .await 229 377 .into_diagnostic()?; 230 - let mut output_file = crate::utils::create_file(output_path.as_ref()).await?; 378 + 379 + // Change extension to .html 380 + let output_path = output_path.as_ref().with_extension("html"); 381 + let mut output_file = crate::utils::create_file(&output_path).await?; 382 + let context = context.clone_with_path(input_path); 383 + 384 + // Write document head 385 + write_document_head(&context, &mut output_file, CssMode::Linked, &output_path).await?; 386 + 387 + // Write body content 388 + let output = export_page(&contents, context).await?; 389 + output_file 390 + .write_all(output.as_bytes()) 391 + .await 392 + .into_diagnostic()?; 393 + 394 + // Write document footer 395 + write_document_footer(&mut output_file).await?; 396 + 397 + Ok(()) 398 + } 399 + 400 + pub async fn write_page_standalone<A>( 401 + context: StaticSiteContext<A>, 402 + input_path: impl AsRef<Path>, 403 + output_path: impl AsRef<Path>, 404 + ) -> Result<(), miette::Report> 405 + where 406 + A: AgentSession + IdentityResolver, 407 + { 408 + let contents = tokio::fs::read_to_string(&input_path) 409 + .await 410 + .into_diagnostic()?; 411 + 412 + // Change extension to .html 413 + let output_path = output_path.as_ref().with_extension("html"); 414 + let mut output_file = crate::utils::create_file(&output_path).await?; 231 415 let context = context.clone_with_path(input_path); 416 + 417 + // Write document head with inline CSS 418 + write_document_head(&context, &mut output_file, CssMode::Inline, &output_path).await?; 419 + 420 + // Write body content 232 421 let output = export_page(&contents, context).await?; 233 422 output_file 234 423 .write_all(output.as_bytes()) 235 424 .await 236 425 .into_diagnostic()?; 426 + 427 + // Write document footer 428 + write_document_footer(&mut output_file).await?; 429 + 237 430 Ok(()) 238 431 } 239 432

+72 -13

crates/weaver-renderer/src/static_site/document.rs

··· 14 14 context: &StaticSiteContext<A>, 15 15 writer: &mut (impl tokio::io::AsyncWrite + Unpin), 16 16 css_mode: CssMode, 17 + output_path: &std::path::Path, 17 18 ) -> miette::Result<()> { 18 19 use tokio::io::AsyncWriteExt; 19 20 20 21 // Get title from frontmatter or current path 21 - let title = if let Some(path) = context.dir_contents.as_ref() 22 + let title = if let Some(path) = context 23 + .dir_contents 24 + .as_ref() 22 25 .and_then(|contents| contents.get(context.position)) 23 26 { 24 - context.titles.get(path) 27 + context 28 + .titles 29 + .get(path) 25 30 .map(|t| t.value().to_string()) 26 31 .unwrap_or_else(|| { 27 32 path.file_stem() ··· 33 38 "Untitled".to_string() 34 39 }; 35 40 36 - writer.write_all(b"<!DOCTYPE html>\n").await.into_diagnostic()?; 37 - writer.write_all(b"<html lang=\"en\">\n").await.into_diagnostic()?; 41 + // Calculate relative path to root based on output file depth 42 + let relative_to_root = if let Ok(rel) = output_path.strip_prefix(&context.destination) { 43 + let depth = rel.components().count() - 1; // -1 because the file itself doesn't count 44 + if depth == 0 { 45 + ".".to_string() 46 + } else { 47 + "../".repeat(depth) 48 + } 49 + } else { 50 + ".".to_string() 51 + }; 52 + 53 + writer 54 + .write_all(b"<!DOCTYPE html>\n") 55 + .await 56 + .into_diagnostic()?; 57 + writer 58 + .write_all(b"<html lang=\"en\">\n") 59 + .await 60 + .into_diagnostic()?; 38 61 writer.write_all(b"<head>\n").await.into_diagnostic()?; 39 - writer.write_all(b" <meta charset=\"utf-8\">\n").await.into_diagnostic()?; 40 - writer.write_all(b" <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n").await.into_diagnostic()?; 62 + writer 63 + .write_all(b" <meta charset=\"utf-8\">\n") 64 + .await 65 + .into_diagnostic()?; 66 + writer 67 + .write_all(b" <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n") 68 + .await 69 + .into_diagnostic()?; 41 70 42 71 // Title 43 72 writer.write_all(b" <title>").await.into_diagnostic()?; ··· 47 76 // CSS 48 77 match css_mode { 49 78 CssMode::Linked => { 50 - writer.write_all(b" <link rel=\"stylesheet\" href=\"/css/base.css\">\n").await.into_diagnostic()?; 51 - writer.write_all(b" <link rel=\"stylesheet\" href=\"/css/syntax.css\">\n").await.into_diagnostic()?; 79 + writer 80 + .write_all(format!(" <link rel=\"stylesheet\" href=\"{}/css/base.css\">\n", relative_to_root).as_bytes()) 81 + .await 82 + .into_diagnostic()?; 83 + writer 84 + .write_all(format!(" <link rel=\"stylesheet\" href=\"{}/css/syntax.css\">\n", relative_to_root).as_bytes()) 85 + .await 86 + .into_diagnostic()?; 52 87 } 53 88 CssMode::Inline => { 54 89 let default_theme = Theme::default(); 55 90 let theme = context.theme.as_deref().unwrap_or(&default_theme); 56 91 57 92 writer.write_all(b" <style>\n").await.into_diagnostic()?; 58 - writer.write_all(generate_base_css(theme).as_bytes()).await.into_diagnostic()?; 93 + writer 94 + .write_all(generate_base_css(theme).as_bytes()) 95 + .await 96 + .into_diagnostic()?; 59 97 writer.write_all(b" </style>\n").await.into_diagnostic()?; 60 98 61 99 writer.write_all(b" <style>\n").await.into_diagnostic()?; 62 - let syntax_css = generate_syntax_css(&theme.syntect_theme_name, &context.syntax_set)?; 63 - writer.write_all(syntax_css.as_bytes()).await.into_diagnostic()?; 100 + let syntax_css = generate_syntax_css(theme, &context.syntax_set)?; 101 + writer 102 + .write_all(syntax_css.as_bytes()) 103 + .await 104 + .into_diagnostic()?; 64 105 writer.write_all(b" </style>\n").await.into_diagnostic()?; 65 106 } 66 107 } ··· 75 116 } 76 117 KaTeXSource::Local(path) => { 77 118 let path_str = path.to_string_lossy(); 78 - writer.write_all(format!(" <link rel=\"stylesheet\" href=\"{}/katex.min.css\">\n", path_str).as_bytes()).await.into_diagnostic()?; 79 - writer.write_all(format!(" <script defer src=\"{}/katex.min.js\"></script>\n", path_str).as_bytes()).await.into_diagnostic()?; 119 + writer 120 + .write_all( 121 + format!( 122 + " <link rel=\"stylesheet\" href=\"{}/katex.min.css\">\n", 123 + path_str 124 + ) 125 + .as_bytes(), 126 + ) 127 + .await 128 + .into_diagnostic()?; 129 + writer 130 + .write_all( 131 + format!( 132 + " <script defer src=\"{}/katex.min.js\"></script>\n", 133 + path_str 134 + ) 135 + .as_bytes(), 136 + ) 137 + .await 138 + .into_diagnostic()?; 80 139 writer.write_all(format!(" <script defer src=\"{}/contrib/auto-render.min.js\" onload=\"renderMathInElement(document.body);\"></script>\n", path_str).as_bytes()).await.into_diagnostic()?; 81 140 } 82 141 }

+3 -1

crates/weaver-renderer/src/static_site/writer.rs

··· 109 109 ) { 110 110 Ok(_) => { 111 111 self.write(&temp_output)?; 112 - }, 112 + } 113 113 Err(_) => { 114 114 // Fallback to plain code block 115 115 self.write("<pre><code class=\"language-")?; ··· 518 518 id, 519 519 attrs, 520 520 } => { 521 + println!("Image tag {}", dest_url); 521 522 self.write_image(Tag::Image { 522 523 link_type, 523 524 dest_url, ··· 534 535 id, 535 536 attrs, 536 537 } => { 538 + println!("Embed {:?}: {} - {}", embed_type, title, dest_url); 537 539 if let Some(attrs) = attrs { 538 540 if let Some((_, content)) = attrs 539 541 .attrs

+13 -4

crates/weaver-renderer/src/theme.rs

··· 1 1 use smol_str::SmolStr; 2 + use std::path::PathBuf; 2 3 3 4 #[derive(Debug, Clone)] 4 5 pub struct Theme { ··· 6 7 pub fonts: FontScheme, 7 8 pub spacing: SpacingScheme, 8 9 pub syntect_theme_name: SmolStr, 10 + pub custom_syntect_theme_path: Option<PathBuf>, 9 11 } 10 12 11 13 #[derive(Debug, Clone)] ··· 36 38 colors: ColorScheme::default(), 37 39 fonts: FontScheme::default(), 38 40 spacing: SpacingScheme::default(), 39 - syntect_theme_name: SmolStr::new("base16-ocean.dark"), 41 + syntect_theme_name: SmolStr::new("rose-pine"), 42 + custom_syntect_theme_path: None, 40 43 } 41 44 } 42 45 } ··· 55 58 impl Default for FontScheme { 56 59 fn default() -> Self { 57 60 Self { 58 - body: SmolStr::new("system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif"), 59 - heading: SmolStr::new("system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif"), 60 - monospace: SmolStr::new("'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, monospace"), 61 + body: SmolStr::new( 62 + "IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif", 63 + ), 64 + heading: SmolStr::new( 65 + "IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif", 66 + ), 67 + monospace: SmolStr::new( 68 + "'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace", 69 + ), 61 70 } 62 71 } 63 72 }

+316

crates/weaver-renderer/themes/rose-pine-dawn.tmTheme

··· 1 + <?xml version="1.0" encoding="UTF-8"?> 2 + <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> 3 + <plist version="1.0"> 4 + <dict> 5 + <key>name</key> 6 + <string>Rosé Pine Dawn</string> 7 + <key>settings</key> 8 + <array> 9 + <dict> 10 + <key>settings</key> 11 + <dict> 12 + <key>background</key> 13 + <string>#faf4ed</string> 14 + <key>caret</key> 15 + <string>#cecacd</string> 16 + <key>foreground</key> 17 + <string>#575279</string> 18 + <key>invisibles</key> 19 + <string>#fffaf3</string> 20 + <key>lineHighlight</key> 21 + <string>#f4ede8</string> 22 + <key>selection</key> 23 + <string>#dfdad9</string> 24 + </dict> 25 + </dict> 26 + <dict> 27 + <key>name</key> 28 + <string>Comment</string> 29 + <key>scope</key> 30 + <string>comment</string> 31 + <key>settings</key> 32 + <dict> 33 + <key>fontStyle</key> 34 + <string>italic</string> 35 + <key>foreground</key> 36 + <string>#797593</string> 37 + </dict> 38 + </dict> 39 + <dict> 40 + <key>name</key> 41 + <string>String</string> 42 + <key>scope</key> 43 + <string>string, punctuation.definition.string</string> 44 + <key>settings</key> 45 + <dict> 46 + <key>foreground</key> 47 + <string>#ea9d34</string> 48 + </dict> 49 + </dict> 50 + <dict> 51 + <key>name</key> 52 + <string>Number</string> 53 + <key>scope</key> 54 + <string>constant.numeric</string> 55 + <key>settings</key> 56 + <dict> 57 + <key>foreground</key> 58 + <string>#ea9d34</string> 59 + </dict> 60 + </dict> 61 + <dict> 62 + <key>name</key> 63 + <string>Built-in constant</string> 64 + <key>scope</key> 65 + <string>constant.language</string> 66 + <key>settings</key> 67 + <dict> 68 + <key>fontStyle</key> 69 + <string>bold</string> 70 + <key>foreground</key> 71 + <string>#ea9d34</string> 72 + </dict> 73 + </dict> 74 + <dict> 75 + <key>name</key> 76 + <string>User-defined constant</string> 77 + <key>scope</key> 78 + <string>constant.character, constant.other</string> 79 + <key>settings</key> 80 + <dict> 81 + <key>foreground</key> 82 + <string>#ea9d34</string> 83 + </dict> 84 + </dict> 85 + <dict> 86 + <key>name</key> 87 + <string>Variable</string> 88 + <key>scope</key> 89 + <string>variable</string> 90 + <key>settings</key> 91 + <dict> 92 + <key>fontStyle</key> 93 + <string>italic</string> 94 + <key>foreground</key> 95 + <string>#575279</string> 96 + </dict> 97 + </dict> 98 + <dict> 99 + <key>name</key> 100 + <string>Keyword</string> 101 + <key>scope</key> 102 + <string>keyword</string> 103 + <key>settings</key> 104 + <dict> 105 + <key>foreground</key> 106 + <string>#286983</string> 107 + </dict> 108 + </dict> 109 + <dict> 110 + <key>name</key> 111 + <string>Storage</string> 112 + <key>scope</key> 113 + <string>storage</string> 114 + <key>settings</key> 115 + <dict> 116 + <key>fontStyle</key> 117 + <string></string> 118 + <key>foreground</key> 119 + <string>#56949f</string> 120 + </dict> 121 + </dict> 122 + <dict> 123 + <key>name</key> 124 + <string>Storage type</string> 125 + <key>scope</key> 126 + <string>storage.type</string> 127 + <key>settings</key> 128 + <dict> 129 + <key>fontStyle</key> 130 + <string></string> 131 + <key>foreground</key> 132 + <string>#56949f</string> 133 + </dict> 134 + </dict> 135 + <dict> 136 + <key>name</key> 137 + <string>Class name</string> 138 + <key>scope</key> 139 + <string>entity.name.class</string> 140 + <key>settings</key> 141 + <dict> 142 + <key>fontStyle</key> 143 + <string>bold</string> 144 + <key>foreground</key> 145 + <string>#286983</string> 146 + </dict> 147 + </dict> 148 + <dict> 149 + <key>name</key> 150 + <string>Inherited class</string> 151 + <key>scope</key> 152 + <string>entity.other.inherited-class</string> 153 + <key>settings</key> 154 + <dict> 155 + <key>fontStyle</key> 156 + <string>italic </string> 157 + <key>foreground</key> 158 + <string>#286983</string> 159 + </dict> 160 + </dict> 161 + <dict> 162 + <key>name</key> 163 + <string>Function name</string> 164 + <key>scope</key> 165 + <string>entity.name.function</string> 166 + <key>settings</key> 167 + <dict> 168 + <key>fontStyle</key> 169 + <string>italic</string> 170 + <key>foreground</key> 171 + <string>#d7827e</string> 172 + </dict> 173 + </dict> 174 + <dict> 175 + <key>name</key> 176 + <string>Function argument</string> 177 + <key>scope</key> 178 + <string>variable.parameter</string> 179 + <key>settings</key> 180 + <dict> 181 + <key>fontStyle</key> 182 + <string></string> 183 + <key>foreground</key> 184 + <string>#907aa9</string> 185 + </dict> 186 + </dict> 187 + <dict> 188 + <key>name</key> 189 + <string>Tag name</string> 190 + <key>scope</key> 191 + <string>entity.name.tag</string> 192 + <key>settings</key> 193 + <dict> 194 + <key>fontStyle</key> 195 + <string>bold</string> 196 + <key>foreground</key> 197 + <string>#286983</string> 198 + </dict> 199 + </dict> 200 + <dict> 201 + <key>name</key> 202 + <string>Tag attribute</string> 203 + <key>scope</key> 204 + <string>entity.other.attribute-name</string> 205 + <key>settings</key> 206 + <dict> 207 + <key>fontStyle</key> 208 + <string></string> 209 + <key>foreground</key> 210 + <string>#907aa9</string> 211 + </dict> 212 + </dict> 213 + <dict> 214 + <key>name</key> 215 + <string>Library function</string> 216 + <key>scope</key> 217 + <string>support.function</string> 218 + <key>settings</key> 219 + <dict> 220 + <key>fontStyle</key> 221 + <string>bold</string> 222 + <key>foreground</key> 223 + <string>#d7827e</string> 224 + </dict> 225 + </dict> 226 + <dict> 227 + <key>name</key> 228 + <string>Library constant</string> 229 + <key>scope</key> 230 + <string>support.constant</string> 231 + <key>settings</key> 232 + <dict> 233 + <key>fontStyle</key> 234 + <string>bold</string> 235 + <key>foreground</key> 236 + <string>#ea9d34</string> 237 + </dict> 238 + </dict> 239 + <dict> 240 + <key>name</key> 241 + <string>Library class/type</string> 242 + <key>scope</key> 243 + <string>support.type, support.class</string> 244 + <key>settings</key> 245 + <dict> 246 + <key>fontStyle</key> 247 + <string>bold</string> 248 + <key>foreground</key> 249 + <string>#56949f</string> 250 + </dict> 251 + </dict> 252 + <dict> 253 + <key>name</key> 254 + <string>Library variable</string> 255 + <key>scope</key> 256 + <string>support.other.variable</string> 257 + <key>settings</key> 258 + <dict> 259 + <key>fontStyle</key> 260 + <string>bold</string> 261 + <key>foreground</key> 262 + <string>#b4637a</string> 263 + </dict> 264 + </dict> 265 + <dict> 266 + <key>name</key> 267 + <string>Invalid</string> 268 + <key>scope</key> 269 + <string>invalid</string> 270 + <key>settings</key> 271 + <dict> 272 + <key>background</key> 273 + <string>#b4637a</string> 274 + <key>fontStyle</key> 275 + <string></string> 276 + <key>foreground</key> 277 + <string>#575279</string> 278 + </dict> 279 + </dict> 280 + <dict> 281 + <key>name</key> 282 + <string>Invalid deprecated</string> 283 + <key>scope</key> 284 + <string>invalid.deprecated</string> 285 + <key>settings</key> 286 + <dict> 287 + <key>background</key> 288 + <string>#907aa9</string> 289 + <key>foreground</key> 290 + <string>#575279</string> 291 + </dict> 292 + </dict> 293 + <dict> 294 + <key>name</key> 295 + <string>Punctuation, Operators</string> 296 + <key>scope</key> 297 + <string>punctuation, keyword.operator</string> 298 + <key>settings</key> 299 + <dict> 300 + <key>foreground</key> 301 + <string>#797593</string> 302 + </dict> 303 + </dict> 304 + </array> 305 + <key>colorSpaceName</key> 306 + <string>sRGB</string> 307 + <key>semanticClass</key> 308 + <string>theme.light.rosé-pine-dawn</string> 309 + <key>author</key> 310 + <string>arrrgi</string> 311 + <key>comment</key> 312 + <string>All natural pine, faux fur and a bit of soho vibes for the classy minimalist</string> 313 + <key>uuid</key> 314 + <string>BB4B4616-E742-41D5-BB5B-63D45FA614F</string> 315 + </dict> 316 + </plist>

+316

crates/weaver-renderer/themes/rose-pine.tmTheme

··· 1 + <?xml version="1.0" encoding="UTF-8"?> 2 + <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> 3 + <plist version="1.0"> 4 + <dict> 5 + <key>name</key> 6 + <string>Rosé Pine</string> 7 + <key>settings</key> 8 + <array> 9 + <dict> 10 + <key>settings</key> 11 + <dict> 12 + <key>background</key> 13 + <string>#191724</string> 14 + <key>caret</key> 15 + <string>#524f67</string> 16 + <key>foreground</key> 17 + <string>#e0def4</string> 18 + <key>invisibles</key> 19 + <string>#1f1d2e</string> 20 + <key>lineHighlight</key> 21 + <string>#21202e</string> 22 + <key>selection</key> 23 + <string>#403d52</string> 24 + </dict> 25 + </dict> 26 + <dict> 27 + <key>name</key> 28 + <string>Comment</string> 29 + <key>scope</key> 30 + <string>comment</string> 31 + <key>settings</key> 32 + <dict> 33 + <key>fontStyle</key> 34 + <string>italic</string> 35 + <key>foreground</key> 36 + <string>#908caa</string> 37 + </dict> 38 + </dict> 39 + <dict> 40 + <key>name</key> 41 + <string>String</string> 42 + <key>scope</key> 43 + <string>string, punctuation.definition.string</string> 44 + <key>settings</key> 45 + <dict> 46 + <key>foreground</key> 47 + <string>#f6c177</string> 48 + </dict> 49 + </dict> 50 + <dict> 51 + <key>name</key> 52 + <string>Number</string> 53 + <key>scope</key> 54 + <string>constant.numeric</string> 55 + <key>settings</key> 56 + <dict> 57 + <key>foreground</key> 58 + <string>#f6c177</string> 59 + </dict> 60 + </dict> 61 + <dict> 62 + <key>name</key> 63 + <string>Built-in constant</string> 64 + <key>scope</key> 65 + <string>constant.language</string> 66 + <key>settings</key> 67 + <dict> 68 + <key>fontStyle</key> 69 + <string>bold</string> 70 + <key>foreground</key> 71 + <string>#f6c177</string> 72 + </dict> 73 + </dict> 74 + <dict> 75 + <key>name</key> 76 + <string>User-defined constant</string> 77 + <key>scope</key> 78 + <string>constant.character, constant.other</string> 79 + <key>settings</key> 80 + <dict> 81 + <key>foreground</key> 82 + <string>#f6c177</string> 83 + </dict> 84 + </dict> 85 + <dict> 86 + <key>name</key> 87 + <string>Variable</string> 88 + <key>scope</key> 89 + <string>variable</string> 90 + <key>settings</key> 91 + <dict> 92 + <key>fontStyle</key> 93 + <string>italic</string> 94 + <key>foreground</key> 95 + <string>#e0def4</string> 96 + </dict> 97 + </dict> 98 + <dict> 99 + <key>name</key> 100 + <string>Keyword</string> 101 + <key>scope</key> 102 + <string>keyword</string> 103 + <key>settings</key> 104 + <dict> 105 + <key>foreground</key> 106 + <string>#31748f</string> 107 + </dict> 108 + </dict> 109 + <dict> 110 + <key>name</key> 111 + <string>Storage</string> 112 + <key>scope</key> 113 + <string>storage</string> 114 + <key>settings</key> 115 + <dict> 116 + <key>fontStyle</key> 117 + <string></string> 118 + <key>foreground</key> 119 + <string>#9ccfd8</string> 120 + </dict> 121 + </dict> 122 + <dict> 123 + <key>name</key> 124 + <string>Storage type</string> 125 + <key>scope</key> 126 + <string>storage.type</string> 127 + <key>settings</key> 128 + <dict> 129 + <key>fontStyle</key> 130 + <string></string> 131 + <key>foreground</key> 132 + <string>#9ccfd8</string> 133 + </dict> 134 + </dict> 135 + <dict> 136 + <key>name</key> 137 + <string>Class name</string> 138 + <key>scope</key> 139 + <string>entity.name.class</string> 140 + <key>settings</key> 141 + <dict> 142 + <key>fontStyle</key> 143 + <string>bold</string> 144 + <key>foreground</key> 145 + <string>#31748f</string> 146 + </dict> 147 + </dict> 148 + <dict> 149 + <key>name</key> 150 + <string>Inherited class</string> 151 + <key>scope</key> 152 + <string>entity.other.inherited-class</string> 153 + <key>settings</key> 154 + <dict> 155 + <key>fontStyle</key> 156 + <string>italic </string> 157 + <key>foreground</key> 158 + <string>#31748f</string> 159 + </dict> 160 + </dict> 161 + <dict> 162 + <key>name</key> 163 + <string>Function name</string> 164 + <key>scope</key> 165 + <string>entity.name.function</string> 166 + <key>settings</key> 167 + <dict> 168 + <key>fontStyle</key> 169 + <string>italic</string> 170 + <key>foreground</key> 171 + <string>#ebbcba</string> 172 + </dict> 173 + </dict> 174 + <dict> 175 + <key>name</key> 176 + <string>Function argument</string> 177 + <key>scope</key> 178 + <string>variable.parameter</string> 179 + <key>settings</key> 180 + <dict> 181 + <key>fontStyle</key> 182 + <string></string> 183 + <key>foreground</key> 184 + <string>#c4a7e7</string> 185 + </dict> 186 + </dict> 187 + <dict> 188 + <key>name</key> 189 + <string>Tag name</string> 190 + <key>scope</key> 191 + <string>entity.name.tag</string> 192 + <key>settings</key> 193 + <dict> 194 + <key>fontStyle</key> 195 + <string>bold</string> 196 + <key>foreground</key> 197 + <string>#31748f</string> 198 + </dict> 199 + </dict> 200 + <dict> 201 + <key>name</key> 202 + <string>Tag attribute</string> 203 + <key>scope</key> 204 + <string>entity.other.attribute-name</string> 205 + <key>settings</key> 206 + <dict> 207 + <key>fontStyle</key> 208 + <string></string> 209 + <key>foreground</key> 210 + <string>#c4a7e7</string> 211 + </dict> 212 + </dict> 213 + <dict> 214 + <key>name</key> 215 + <string>Library function</string> 216 + <key>scope</key> 217 + <string>support.function</string> 218 + <key>settings</key> 219 + <dict> 220 + <key>fontStyle</key> 221 + <string>bold</string> 222 + <key>foreground</key> 223 + <string>#ebbcba</string> 224 + </dict> 225 + </dict> 226 + <dict> 227 + <key>name</key> 228 + <string>Library constant</string> 229 + <key>scope</key> 230 + <string>support.constant</string> 231 + <key>settings</key> 232 + <dict> 233 + <key>fontStyle</key> 234 + <string>bold</string> 235 + <key>foreground</key> 236 + <string>#f6c177</string> 237 + </dict> 238 + </dict> 239 + <dict> 240 + <key>name</key> 241 + <string>Library class/type</string> 242 + <key>scope</key> 243 + <string>support.type, support.class</string> 244 + <key>settings</key> 245 + <dict> 246 + <key>fontStyle</key> 247 + <string>bold</string> 248 + <key>foreground</key> 249 + <string>#9ccfd8</string> 250 + </dict> 251 + </dict> 252 + <dict> 253 + <key>name</key> 254 + <string>Library variable</string> 255 + <key>scope</key> 256 + <string>support.other.variable</string> 257 + <key>settings</key> 258 + <dict> 259 + <key>fontStyle</key> 260 + <string>bold</string> 261 + <key>foreground</key> 262 + <string>#eb6f92</string> 263 + </dict> 264 + </dict> 265 + <dict> 266 + <key>name</key> 267 + <string>Invalid</string> 268 + <key>scope</key> 269 + <string>invalid</string> 270 + <key>settings</key> 271 + <dict> 272 + <key>background</key> 273 + <string>#eb6f92</string> 274 + <key>fontStyle</key> 275 + <string></string> 276 + <key>foreground</key> 277 + <string>#e0def4</string> 278 + </dict> 279 + </dict> 280 + <dict> 281 + <key>name</key> 282 + <string>Invalid deprecated</string> 283 + <key>scope</key> 284 + <string>invalid.deprecated</string> 285 + <key>settings</key> 286 + <dict> 287 + <key>background</key> 288 + <string>#c4a7e7</string> 289 + <key>foreground</key> 290 + <string>#e0def4</string> 291 + </dict> 292 + </dict> 293 + <dict> 294 + <key>name</key> 295 + <string>Punctuation, Operators</string> 296 + <key>scope</key> 297 + <string>punctuation, keyword.operator</string> 298 + <key>settings</key> 299 + <dict> 300 + <key>foreground</key> 301 + <string>#908caa</string> 302 + </dict> 303 + </dict> 304 + </array> 305 + <key>colorSpaceName</key> 306 + <string>sRGB</string> 307 + <key>semanticClass</key> 308 + <string>theme.dark.rosé-pine</string> 309 + <key>author</key> 310 + <string>arrrgi</string> 311 + <key>comment</key> 312 + <string>All natural pine, faux fur and a bit of soho vibes for the classy minimalist</string> 313 + <key>uuid</key> 314 + <string>14991673-80EB-41A2-BEFF-03216A233730</string> 315 + </dict> 316 + </plist>

+158

essay/css/base.css

··· 1 + /* CSS Reset */ 2 + *, *::before, *::after { 3 + box-sizing: border-box; 4 + margin: 0; 5 + padding: 0; 6 + } 7 + 8 + /* CSS Variables */ 9 + :root { 10 + --color-background: #ffffff; 11 + --color-foreground: #2b303b; 12 + --color-link: #0366d6; 13 + --color-link-hover: #0256b8; 14 + 15 + --font-body: IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; 16 + --font-heading: IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; 17 + --font-mono: 'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace; 18 + 19 + --spacing-base: 16px; 20 + --spacing-line-height: 1.6; 21 + --spacing-scale: 1.25; 22 + } 23 + 24 + /* Base Styles */ 25 + html { 26 + font-size: var(--spacing-base); 27 + line-height: var(--spacing-line-height); 28 + } 29 + 30 + body { 31 + font-family: var(--font-body); 32 + color: var(--color-foreground); 33 + background-color: var(--color-background); 34 + max-width: 65ch; 35 + margin: 0 auto; 36 + padding: 2rem 1rem; 37 + } 38 + 39 + /* Typography */ 40 + h1, h2, h3, h4, h5, h6 { 41 + font-family: var(--font-heading); 42 + margin-top: calc(1rem * var(--spacing-scale)); 43 + margin-bottom: 0.5rem; 44 + line-height: 1.2; 45 + } 46 + 47 + h1 { font-size: 2.5rem; } 48 + h2 { font-size: 2rem; } 49 + h3 { font-size: 1.5rem; } 50 + h4 { font-size: 1.25rem; } 51 + h5 { font-size: 1.125rem; } 52 + h6 { font-size: 1rem; } 53 + 54 + p { 55 + margin-bottom: 1rem; 56 + } 57 + 58 + a { 59 + color: var(--color-link); 60 + text-decoration: none; 61 + } 62 + 63 + a:hover { 64 + color: var(--color-link-hover); 65 + text-decoration: underline; 66 + } 67 + 68 + /* Lists */ 69 + ul, ol { 70 + margin-left: 2rem; 71 + margin-bottom: 1rem; 72 + } 73 + 74 + li { 75 + margin-bottom: 0.25rem; 76 + } 77 + 78 + /* Code */ 79 + code { 80 + font-family: var(--font-mono); 81 + background-color: rgba(0, 0, 0, 0.05); 82 + padding: 0.125rem 0.25rem; 83 + border-radius: 3px; 84 + font-size: 0.9em; 85 + } 86 + 87 + pre { 88 + overflow-x: auto; 89 + margin-bottom: 1rem; 90 + } 91 + 92 + pre code { 93 + display: block; 94 + padding: 1rem; 95 + background-color: rgba(0, 0, 0, 0.03); 96 + border-radius: 5px; 97 + } 98 + 99 + /* Math */ 100 + .math { 101 + font-family: var(--font-mono); 102 + } 103 + 104 + .math-display { 105 + display: block; 106 + margin: 1rem 0; 107 + text-align: center; 108 + } 109 + 110 + /* Blockquotes */ 111 + blockquote { 112 + border-left: 4px solid var(--color-link); 113 + padding-left: 1rem; 114 + margin: 1rem 0; 115 + font-style: italic; 116 + } 117 + 118 + /* Tables */ 119 + table { 120 + border-collapse: collapse; 121 + width: 100%; 122 + margin-bottom: 1rem; 123 + } 124 + 125 + th, td { 126 + border: 1px solid rgba(0, 0, 0, 0.1); 127 + padding: 0.5rem; 128 + text-align: left; 129 + } 130 + 131 + th { 132 + background-color: rgba(0, 0, 0, 0.05); 133 + font-weight: 600; 134 + } 135 + 136 + /* Footnotes */ 137 + .footnote-reference { 138 + font-size: 0.8em; 139 + } 140 + 141 + .footnote-definition { 142 + margin-top: 2rem; 143 + padding-top: 0.5rem; 144 + border-top: 1px solid rgba(0, 0, 0, 0.1); 145 + font-size: 0.9em; 146 + } 147 + 148 + .footnote-definition-label { 149 + font-weight: 600; 150 + margin-right: 0.5rem; 151 + } 152 + 153 + /* Horizontal Rule */ 154 + hr { 155 + border: none; 156 + border-top: 1px solid rgba(0, 0, 0, 0.1); 157 + margin: 2rem 0; 158 + }

+88

essay/css/syntax.css

··· 1 + /* 2 + * theme "Rosé Pine" generated by syntect 3 + */ 4 + 5 + .wvrcode-code { 6 + color: #e0def4; 7 + background-color: #191724; 8 + } 9 + 10 + .wvrcode-comment { 11 + color: #908caa; 12 + font-style: italic; 13 + } 14 + .wvrcode-string, .wvrcode-punctuation.wvrcode-definition.wvrcode-string { 15 + color: #f6c177; 16 + } 17 + .wvrcode-constant.wvrcode-numeric { 18 + color: #f6c177; 19 + } 20 + .wvrcode-constant.wvrcode-language { 21 + color: #f6c177; 22 + font-weight: bold; 23 + } 24 + .wvrcode-constant.wvrcode-character, .wvrcode-constant.wvrcode-other { 25 + color: #f6c177; 26 + } 27 + .wvrcode-variable { 28 + color: #e0def4; 29 + font-style: italic; 30 + } 31 + .wvrcode-keyword { 32 + color: #31748f; 33 + } 34 + .wvrcode-storage { 35 + color: #9ccfd8; 36 + } 37 + .wvrcode-storage.wvrcode-type { 38 + color: #9ccfd8; 39 + } 40 + .wvrcode-entity.wvrcode-name.wvrcode-class { 41 + color: #31748f; 42 + font-weight: bold; 43 + } 44 + .wvrcode-entity.wvrcode-other.wvrcode-inherited-class { 45 + color: #31748f; 46 + font-style: italic; 47 + } 48 + .wvrcode-entity.wvrcode-name.wvrcode-function { 49 + color: #ebbcba; 50 + font-style: italic; 51 + } 52 + .wvrcode-variable.wvrcode-parameter { 53 + color: #c4a7e7; 54 + } 55 + .wvrcode-entity.wvrcode-name.wvrcode-tag { 56 + color: #31748f; 57 + font-weight: bold; 58 + } 59 + .wvrcode-entity.wvrcode-other.wvrcode-attribute-name { 60 + color: #c4a7e7; 61 + } 62 + .wvrcode-support.wvrcode-function { 63 + color: #ebbcba; 64 + font-weight: bold; 65 + } 66 + .wvrcode-support.wvrcode-constant { 67 + color: #f6c177; 68 + font-weight: bold; 69 + } 70 + .wvrcode-support.wvrcode-type, .wvrcode-support.wvrcode-class { 71 + color: #9ccfd8; 72 + font-weight: bold; 73 + } 74 + .wvrcode-support.wvrcode-other.wvrcode-variable { 75 + color: #eb6f92; 76 + font-weight: bold; 77 + } 78 + .wvrcode-invalid { 79 + color: #e0def4; 80 + background-color: #eb6f92; 81 + } 82 + .wvrcode-invalid.wvrcode-deprecated { 83 + color: #e0def4; 84 + background-color: #c4a7e7; 85 + } 86 + .wvrcode-punctuation, .wvrcode-keyword.wvrcode-operator { 87 + color: #908caa; 88 + }

+12

essay/entry/Features/Allocator.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Allocator</title> 7 + <link rel="stylesheet" href="../..//css/base.css"> 8 + <link rel="stylesheet" href="../..//css/syntax.css"> 9 + </head> 10 + <body> 11 + </body> 12 + </html>

+204

essay/entry/Features/Effects.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Effects</title> 7 + <link rel="stylesheet" href="../..//css/base.css"> 8 + <link rel="stylesheet" href="../..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <h2>Overview</h2> 12 + Alloy's effect system provides explicit tracking of side effects at the type level. This allows for better reasoning about code behavior and enables powerful optimizations while maintaining clarity about what a function can do. 13 + <h2>Core Concepts</h2> 14 + <h3>Effect Declaration</h3> 15 + Effects are declared using the <code>effect</code> keyword: 16 + <pre><code class="language-Rust">effect IO { 17 + read_line() -> String 18 + print(String) 19 + } 20 + 21 + effect State[T] { 22 + get() -> T 23 + set(T) 24 + } 25 + 26 + effect Random { 27 + next_int(min: i32, max: i32) -> i32 28 + } 29 + </code></pre> 30 + <h3>Using Effects</h3> 31 + Functions must declare which effects they use with the <code>with</code> keyword: 32 + <pre><code class="language-Rust">fn get_user_name() -> String with IO { 33 + print("Enter your name: ") 34 + read_line() 35 + } 36 + 37 + fn generate_id() -> i32 with Random { 38 + next_int(0, 1000) 39 + } 40 + </code></pre> 41 + <h3>Multiple Effects</h3> 42 + Functions can use multiple effects: 43 + <pre><code class="language-Rust">fn interactive_random() -> i32 with IO, Random { 44 + print("Generating a random number...") 45 + let num = next_int(0, 100) 46 + print("Generated: {num}") 47 + num 48 + } 49 + </code></pre> 50 + <h3>Effect Handlers</h3> 51 + Effects are implemented using handlers: 52 + <pre><code class="language-Rust">handler ConsoleIO for IO { 53 + fn read_line() -> String { 54 + // Implementation using actual console I/O 55 + } 56 + 57 + fn print(message: String) { 58 + // Implementation using actual console I/O 59 + } 60 + } 61 + 62 + handler TestIO for IO { 63 + let mut inputs: Vec[String] 64 + let mut outputs: Vec[String] 65 + 66 + fn read_line() -> String { 67 + inputs.pop().unwrap_or("Test Input") 68 + } 69 + 70 + fn print(message: String) { 71 + outputs.push(messages) 72 + } 73 + } 74 + </code></pre> 75 + <h3>Running with Effects</h3> 76 + Use the <code>run</code> keyword to execute code with effect handlers: 77 + <pre><code class="language-Rust">fn main() { 78 + // Using real I/O 79 + run with ConsoleIO { 80 + let name = get_user_name() 81 + print("Hello, {name}!") 82 + } 83 + 84 + // Using test I/O 85 + let test_io = TestIO { 86 + inputs: vec!["Test User"], 87 + outputs: vec![] 88 + } 89 + 90 + run with test_io { 91 + let name = get_user_name() 92 + print("Hello, {name}!") 93 + } 94 + 95 + assert_eq(test_io.outputs, ["Enter your name: ", "Hello, Test User!"]) 96 + } 97 + </code></pre> 98 + <h2>Effect Composition</h2> 99 + <h3>Combining Effects</h3> 100 + <pre><code class="language-Rust">effect Logger { 101 + log(message: String) 102 + } 103 + 104 + effect Database { 105 + query(sql: String) -> Result[Row, DbError] 106 + } 107 + 108 + // Combined effect handler 109 + fn process_user() -> Result[(), Error] with Logger, Database, IO { 110 + log("Starting user processing") 111 + let user = match query("SELECT * FROM users LIMIT 1") { 112 + Ok(row) -> row, 113 + Err(e) -> { 114 + log("Database error: {e}") 115 + return Err(e.into()) 116 + } 117 + } 118 + print("Found user: {user.name}") 119 + Ok(()) 120 + } 121 + </code></pre> 122 + <h3>Effect Polymorphism</h3> 123 + <pre><code class="language-Rust">// Generic over any effect that provides logging 124 + 125 + fn audit[E: Logger](action: String) -> () with E { 126 + log("Audit: {action}") 127 + } 128 + </code></pre> 129 + <h2>Best Practices</h2> 130 + <ol> 131 + <li>Effect Granularity</li> 132 + </ol> 133 + <ul> 134 + <li>Keep effects focused and single-purpose</li> 135 + <li>Split large effects into smaller, composable ones</li> 136 + </ul> 137 + <ol start="2"> 138 + <li>Effect Isolation</li> 139 + </ol> 140 + <ul> 141 + <li>Contain effects at the edges of your program</li> 142 + <li>Keep core logic pure when possible</li> 143 + </ul> 144 + <ol start="3"> 145 + <li>Testing with Effects</li> 146 + </ol> 147 + <ul> 148 + <li>Create test handlers for effects</li> 149 + <li>Use effect substitution to simulate different scenarios</li> 150 + </ul> 151 + <ol start="4"> 152 + <li>Effect Documentation</li> 153 + </ol> 154 + <ul> 155 + <li>Document effect requirements clearly</li> 156 + <li>Explain effect interactions in complex systems</li> 157 + </ul> 158 + <ol start="5"> 159 + <li>Effect Performance</li> 160 + </ol> 161 + <ul> 162 + <li>Group related effects to reduce handler overhead</li> 163 + <li>Consider effect batching for performance-critical code</li> 164 + </ul> 165 + <h2>Patterns</h2> 166 + <h3>The Reader Effect</h3> 167 + <pre><code class="language-Rust">effect Reader[C] { 168 + ask() -> C 169 + } 170 + 171 + fn get_config[C]() -> C with Reader[C] { 172 + ask() 173 + } 174 + 175 + fn use_config() -> String with Reader[Config] { 176 + let config = ask() 177 + config.base_url 178 + } 179 + </code></pre> 180 + <h3>The Writer Effect</h3> 181 + <pre><code class="language-Rust">effect Writer[W] { 182 + tell(W) 183 + clear() 184 + } 185 + 186 + fn log_action(action: String) -> () with Writer[String] { 187 + tell("[{timestamp()}] {action}") 188 + } 189 + </code></pre> 190 + <h3>Combining with Pipelines</h3> 191 + <pre><code class="language-Rust">effect Transform { 192 + validate(String) -> Result[String, Error] 193 + normalize(String) -> String 194 + encrypt(String) -> String 195 + } 196 + 197 + fn process_input(input: String) -> Result[String, Error] with Transform { 198 + input 199 + |> validate() 200 + |> map(normalize) 201 + |> map(encrypt) 202 + } 203 + </code></pre></body> 204 + </html>

+211

essay/entry/Features/Traits.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Traits</title> 7 + <link rel="stylesheet" href="../..//css/base.css"> 8 + <link rel="stylesheet" href="../..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <h1>Trait System Guide</h1> 12 + <h2>Overview</h2> 13 + Alloy's trait system builds on Rust's traits while adding powerful features like default implementations, template control, and better composition patterns. 14 + <h2>Core Concepts</h2> 15 + The basics follow Rust closely 16 + <h3>Basic Trait Declaration</h3> 17 + <pre><code class="language-Rust">trait Display { 18 + fn display(self) -> String // Note: no semicolon 19 + } 20 + </code></pre> 21 + <h3>Implementation</h3> 22 + <pre><code class="language-Rust">struct Point { 23 + x: f64 24 + y: f64 25 + } 26 + 27 + impl Display for Point { 28 + fn display(self) -> String { 29 + "({self.x}, {self.y})" // Alloy builds formatting into Strings 30 + } 31 + } 32 + </code></pre> 33 + <h3>Generic Traits</h3> 34 + <pre><code class="language-Rust">trait Container[T] { // Alloy uses [] rather than < > for type parameters 35 + fn add(self, item: T) 36 + fn remove(self) -> Option[T] 37 + fn is_empty(self) -> bool 38 + } 39 + 40 + impl[T] Container[T] for Stack[T] { 41 + fn add(self, item: T) { 42 + self.push(item) 43 + } 44 + 45 + fn remove(self) -> Option[T] { 46 + self.pop() 47 + } 48 + 49 + fn is_empty(self) -> bool { 50 + self.len() == 0 51 + } 52 + } 53 + </code></pre> 54 + <h2>Features</h2> 55 + <h3>Default Implementations</h3> 56 + Like in Rust, traits in Alloy can contain a mix of methods which include a default implementation and ones which require the implementer to provide an implementation. 57 + <pre><code class="language-Rust">trait Collection[T] { 58 + fn is_empty(self) -> bool { 59 + self.len() == 0 60 + } 61 + 62 + fn len(self) -> usize 63 + 64 + fn contains(self, item: T) -> bool { 65 + self.into_iter().any { x in x == item } 66 + } 67 + } 68 + </code></pre> 69 + <h3>Trait Defaults</h3> 70 + Unlike in Rust, associated types in Alloy can carry a default value. Sensible defaults make writing simple things easy, without losing any flexibility. 71 + <pre><code class="language-Rust">// Define a trait with a default implementation strategy 72 + trait ToString { 73 + default = JsonString 74 + fn to_string(self) -> String 75 + } 76 + 77 + // Implementations can override the default 78 + impl ToString for CustomType { 79 + fn to_string(self) -> String { 80 + // Custom implementation 81 + } 82 + } 83 + 84 + // Or use the default 85 + impl ToString for SimpleType default 86 + </code></pre> 87 + <h3>Template Control</h3> 88 + Defaults allow more organic composition and make code simpler. 89 + <pre><code class="language-Rust">trait Serialize[Format] { 90 + default Format = Json 91 + fn serialize(self) -> String 92 + } 93 + 94 + // Use default format 95 + fn save[T: Serialize](item: T) { 96 + item.serialize() // Uses Json format 97 + } 98 + 99 + // Override default format 100 + fn save_xml[T: Serialize[Xml]](item: T) { 101 + item.serialize() // Uses XML format 102 + } 103 + </code></pre> 104 + <h3>Conditional Implementation</h3> 105 + <pre><code class="language-Rust">impl[T: Display] Display for Option[T] { 106 + fn display(self) -> String { 107 + match self { 108 + Some(value) -> value.display() 109 + None -> "None" 110 + } 111 + } 112 + } 113 + </code></pre> 114 + The above snippet, if not defined in either the same crate as Display or the same crate as Option[T], would require a newtype wrapper in Rust due to the orphan rule, and a bunch of extra boilerplate to make it behave nicely. Alloy either avoids or elides all that for you. Types are types and traits are traits, and you should be able to work with them as you wish. The compiler will attempt to resolve them and handle any possible conflicts as expected, without surprises, but if it cannot, or if you want to choose the implementation, you can specify. 115 + <h3>Trait Composition</h3> 116 + Traits can also be composed quite freely using a few simple operators, to build up more complex types, in a way that is easy to understand. 117 + <pre><code class="language-Rust">trait Identified { 118 + fn id(self) -> usize 119 + } 120 + 121 + trait Named { 122 + fn name(self) -> String 123 + } 124 + 125 + // Compose traits 126 + trait Entity = Identified + Named { 127 + // Additional requirements can be added 128 + fn describe(self) -> String { 129 + "{self.id()}: {self.name()}" 130 + } 131 + } 132 + 133 + // Misha can you check my syntax here? 134 + trait Component = Identified + !Named // Marker trait 135 + 136 + trait GameObject = Entity | Component { 137 + fn describe(self) -> String { 138 + match typeof self { 139 + Entity -> (self as Entity).describe() 140 + Component -> "{(self as Identified).id()}" 141 + } 142 + } 143 + } 144 + </code></pre> 145 + <h2>Best Practices</h2> 146 + <ol> 147 + <li>Trait Cohesion</li> 148 + </ol> 149 + <ul> 150 + <li>Keep traits focused on a single responsibility</li> 151 + <li>Use composition for complex behaviors</li> 152 + </ul> 153 + <ol start="2"> 154 + <li>Default Implementations</li> 155 + </ol> 156 + <ul> 157 + <li>Provide sensible defaults when possible</li> 158 + <li>Make defaults efficient and general</li> 159 + </ul> 160 + <ol start="3"> 161 + <li>Template Defaults</li> 162 + </ol> 163 + <ul> 164 + <li>Choose widely applicable defaults</li> 165 + <li>Document default behavior clearly</li> 166 + </ul> 167 + <ol start="4"> 168 + <li>Trait Bounds</li> 169 + </ol> 170 + <ul> 171 + <li>Use minimal trait bounds</li> 172 + <li>Prefer composition over complex bounds</li> 173 + </ul> 174 + <ol start="5"> 175 + <li>Documentation</li> 176 + </ol> 177 + <ul> 178 + <li>Document required behavior clearly</li> 179 + <li>Explain performance characteristics</li> 180 + </ul> 181 + <h2>Patterns</h2> 182 + <h3>Builder Pattern</h3> 183 + <pre><code class="language-Rust">trait Builder[T] { 184 + fn build(self) -> Result[T, BuildError] 185 + 186 + // Optional steps with defaults 187 + fn with_name(self, name: String) -> Self { 188 + self 189 + } 190 + 191 + fn with_id(self, id: usize) -> Self { 192 + self 193 + } 194 + } 195 + </code></pre> 196 + <h3>Type State Pattern</h3> 197 + <pre><code class="language-Rust">trait State { 198 + type Next: State 199 + fn transition(self) -> Next 200 + } 201 + 202 + 203 + implement State for Draft { 204 + type Next = Review 205 + 206 + fn transition(self) -> Review { 207 + Review::new(self) 208 + } 209 + } 210 + </code></pre></body> 211 + </html>

+86

essay/entry/Language Overview.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Language Overview</title> 7 + <link rel="stylesheet" href="..//css/base.css"> 8 + <link rel="stylesheet" href="..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <code>.ac</code> file extension 12 + <h2>Design Philosophy</h2> 13 + <h3>Safety First</h3> 14 + <ul> 15 + <li>Thread-safe by default through Arc</li> 16 + <li>Immutable by default</li> 17 + <li>Explicit effect tracking</li> 18 + <li>Comprehensive compile-time checks</li> 19 + <li>No unsafe blocks</li> 20 + </ul> 21 + <h3>Performance</h3> 22 + <ul> 23 + <li>Zero-cost abstractions where possible</li> 24 + <li>Predictable performance</li> 25 + <li>Efficient compilation to Rust</li> 26 + <li>Optional no-atomic reference counting for embedded systems</li> 27 + <li>Effect system enables compile-time optimizations</li> 28 + </ul> 29 + <h3>Ergonomics</h3> 30 + <ul> 31 + <li>Clear, readable syntax</li> 32 + <li>Powerful type inference</li> 33 + <li>Pipeline operator for fluid data transformation</li> 34 + <li>Pattern matching with exhaustive checking</li> 35 + <li>Trailing closure syntax</li> 36 + </ul> 37 + <h2>Key Features</h2> 38 + <h3>Type System</h3> 39 + <ul> 40 + <li>Strong static typing with powerful type inference</li> 41 + <li>Union types and type narrowing from TypeScript</li> 42 + <li>Advanced trait system with defaults and template control</li> 43 + <li>Square brackets <code>[]</code> for generics/templates instead of angle brackets</li> 44 + <li>Algebraic data types with pattern matching</li> 45 + <li>Optional chaining and null coalescing operators from Swift</li> 46 + </ul> 47 + <pre><code class="language-Rust">// Union types and type narrowing 48 + type StringOrNumber = string | number 49 + 50 + fn process(value: StringOrNumber) { 51 + match typeof value { 52 + "string" -> handle_string(value as string) 53 + "number" -> handle_number(value as number) 54 + } 55 + } 56 + 57 + // Optional chaining and null coalescing 58 + let value = obj?.prop?.method() ?? default_value 59 + </code></pre> 60 + <h3>Memory Management</h3> 61 + <ul> 62 + <li>Implicit Arc (Atomic Reference Counting) by default</li> 63 + <li>Optional non-atomic reference counting for platforms without atomics</li> 64 + <li>Custom allocator support via the effect system</li> 65 + <li>Everything immutable by default</li> 66 + <li>Thread-safe by default through Arc</li> 67 + </ul> 68 + Example: 69 + <pre><code class="language-Rust">// Standard usage - implicit Arc 70 + let shared = ComplexType::new() 71 + 72 + // No-atomic reference counting for embedded platforms 73 + 74 + #[no_atomic] 75 + let basic = ComplexType::new() 76 + 77 + // Custom allocation 78 + 79 + let bump_allocator = BumpAllocator::new(1024) 80 + run with bump_allocator as Alloc { 81 + let temp = ComplexType::new() 82 + } 83 + </code></pre> 84 + ... 85 + </body> 86 + </html>

+1

essay/entry/Logo.svg

··· 1 + <svg fill="0" height="256" width="256" viewBox="0 0 512.08 512.08" xml:space="preserve" stroke="0" stroke-width=".005" xmlns="http://www.w3.org/2000/svg"><path style="color:#000;fill:#000;" d="M203.455 374.098h105.172a10.95 10.95 0 0 1 9.111 4.875l56.885 85.33c4.849 7.277-.367 17.022-9.111 17.023H146.568c-8.744 0-13.96-9.746-9.111-17.023l56.887-85.33a10.95 10.95 0 0 1 9.111-4.875zM186.691 68.86a10.95 10.95 0 0 1 9.147 11.359L181.64 357.813a10.94 10.94 0 0 1-1.825 5.515l-42.662 63.996c-6.236 9.347-20.822 4.36-20.033-6.847l21.582-304.704a10.95 10.95 0 0 1 3.008-6.794l35.277-36.887a10.95 10.95 0 0 1 9.703-3.233zm139.289-.15a10.95 10.95 0 0 1 7.954 3.38l35.279 36.889a10.95 10.95 0 0 1 3.006 6.753l22.742 304.704c.835 11.228-13.783 16.255-20.031 6.888l-42.668-64a10.95 10.95 0 0 1-1.823-5.469L315.086 80.264c-.345-6.26 4.626-11.53 10.894-11.553zM223.66 42.63h64.182a10.95 10.95 0 0 1 10.941 10.538l10.863 288.797c.233 6.204-4.733 11.36-10.94 11.361h-85.331c-6.2 0-11.164-5.143-10.943-11.34L212.717 53.19a10.95 10.95 0 0 1 10.943-10.558z"/><path style="color:#000;fill:#000;" d="M223.66 42.629q-335.49-63.943 0 0Zm0 0a10.953 10.953 0 0 0-10.945 10.56L202.43 341.986c-.22 6.198 4.743 11.342 10.945 11.342h85.33c6.21 0 11.176-5.158 10.943-11.363L298.785 53.168a10.953 10.953 0 0 0-10.943-10.54Zm0 .004h64.182a10.95 10.95 0 0 1 10.94 10.535l10.863 288.797c.232 6.202-4.733 11.358-10.94 11.36h-85.33c-6.199-.001-11.162-5.144-10.941-11.339L212.719 53.19c.21-5.89 5.047-10.556 10.941-10.556zm102.32 26.076c-6.27.023-11.24 5.294-10.896 11.555l15.353 277.591a10.96 10.96 0 0 0 1.823 5.471l42.668 64c3.124 4.685 8.341 5.77 12.674 4.28 4.332-1.49 7.778-5.555 7.36-11.17l-22.741-304.704a10.95 10.95 0 0 0-3.006-6.755l-35.28-36.89a10.95 10.95 0 0 0-7.955-3.378zm0 .004a10.95 10.95 0 0 1 7.952 3.379l35.279 36.888a10.95 10.95 0 0 1 3.006 6.752l22.742 304.704c.417 5.613-3.03 9.676-7.36 11.166-4.33 1.489-9.544.403-12.667-4.28l-42.668-64a10.95 10.95 0 0 1-1.823-5.467L315.088 80.264c-.345-6.258 4.625-11.528 10.892-11.551zm-141.959.031a10.96 10.96 0 0 0-7.035 3.346l-35.277 36.887a10.95 10.95 0 0 0-3.008 6.796L117.12 420.477c-.395 5.605 3.055 9.655 7.383 11.134s9.535.39 12.654-4.285l42.662-63.996a10.96 10.96 0 0 0 1.825-5.518L195.84 80.22a10.953 10.953 0 0 0-11.819-11.475zm0 .006a10.945 10.945 0 0 1 11.815 11.469l-14.197 277.594a10.94 10.94 0 0 1-1.825 5.513l-42.662 63.996c-3.117 4.672-8.322 5.762-12.648 4.283s-7.776-5.525-7.381-11.128l21.582-304.704a10.95 10.95 0 0 1 3.008-6.793l35.277-36.886a10.95 10.95 0 0 1 7.031-3.344zm19.434 305.346a10.95 10.95 0 0 0-9.113 4.875l-56.887 85.33c-4.85 7.278.367 17.026 9.113 17.027h218.944c8.746 0 13.963-9.749 9.113-17.027l-56.885-85.33a10.95 10.95 0 0 0-9.113-4.875zm0 .004h105.172c3.66 0 7.079 1.83 9.11 4.875l56.884 85.33c4.848 7.275-.367 17.018-9.11 17.02H146.569c-8.742-.002-13.957-9.745-9.109-17.02l56.887-85.33a10.95 10.95 0 0 1 9.11-4.875z"/><path style="color:#000;fill:#000;" d="m333.16 96.125 14.33 259.086 28.584 42.875-20.812-278.852z"/></svg>

+56

essay/entry/README.md.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>README.md</title> 7 + <link rel="stylesheet" href="..//css/base.css"> 8 + <link rel="stylesheet" href="..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <img src="Logo.svg" alt="Logo.svg" /> 12 + <h1>Alloy</h1> 13 + Alloy is a language that fuses Rust's power, safety guarantees, and performance with Swift's ergonomics and TypeScript's type system innovations. It features unique systems like explicit effect tracking and an advanced trait system with defaults. It maintains portability and compatibility by transpiling to Rust code, meaning it runs pretty much anywhere Rust does, and can take advantage of the existing Rust ecosystem. 14 + <h2>Key Features</h2> 15 + <ul> 16 + <li>🚀 Performance: (hopefully) Zero-cost abstractions and efficient compilation to Rust</li> 17 + <li>🛡️ Safety: Thread-safe by default with implicit Arc</li> 18 + <li>🎯 Effect Tracking: Explicit side effect management</li> 19 + <li>🧩 Advanced Traits: Flexible trait system with powerful defaults</li> 20 + <li>🔄 Ergonomic Syntax: Clean, expressive code</li> 21 + </ul> 22 + <h2>Example</h2> 23 + <pre><code class="language-Rust">effect IO { 24 + read_line() -> String 25 + print(String) 26 + } 27 + 28 + fn process(input: String) -> String { 29 + input 30 + |> trim() 31 + |> to_uppercase() 32 + |> add_exclamation() 33 + } 34 + 35 + fn main() -> Result[(), Error] with IO { 36 + print("Enter your name: ") 37 + let name = read_line() 38 + let processed = process(name) 39 + print("Hello, {processed}!") 40 + Ok(()) 41 + } 42 + </code></pre> 43 + <h2>Documentation</h2> 44 + <ul> 45 + <li><a href="./Language%20Overview">Language Overview</a></li> 46 + <li><a href="./Syntax%20Guide">Syntax Guide</a></li> 47 + <li><a href="./Traits">Traits</a></li> 48 + <li><a href="./Effects">Effects</a></li> 49 + </ul> 50 + <h2>Status</h2> 51 + <h2>Contributing</h2> 52 + <h2>License</h2> 53 + Alloy is licensed under the MPL-2.0. 54 + <a href="./licenses/MPL-2.0"><img src="https://img.shields.io/badge/License-MPL_2.0-brightgreen.svg" alt="License: MPL 2.0" /></a> 55 + </body> 56 + </html>

+356

essay/entry/Syntax Guide.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Syntax Guide</title> 7 + <link rel="stylesheet" href="..//css/base.css"> 8 + <link rel="stylesheet" href="..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <h2>Core Principles</h2> 12 + <ol> 13 + <li>Clean and consistent syntax that prioritizes readability</li> 14 + <li>Pipeline-oriented flow where appropriate</li> 15 + <li>Explicit over implicit</li> 16 + <li>Thread-local and immutable by default</li> 17 + <li>Square brackets for generics/templates</li> 18 + <li>Minimal noise and ceremony</li> 19 + <li>Predictable formatting rules</li> 20 + </ol> 21 + <h2>Basic Syntax Elements</h2> 22 + <h3>Keywords and Names</h3> 23 + <h4>Functions</h4> 24 + <pre><code class="language-Rust">// Function declaration 25 + fn add(x: i32, y: i32) -> i32 { 26 + x + y 27 + } 28 + 29 + // Async function 30 + fn fetch_data() -> Result[Data, Error] with Async { 31 + // ... 32 + } 33 + 34 + // Generic function 35 + fn map[T, U](value: T, f: fn(T) -> U) -> U { 36 + f(value) 37 + } 38 + </code></pre> 39 + <h4>Variables</h4> 40 + <pre><code class="language-Rust"> 41 + // Immutable by default 42 + let x = 5 43 + 44 + // Mutable variables must be declared with 'let mut' 45 + let mut count = 0 46 + 47 + // Explicit type annotation 48 + let name: String = "Alice" 49 + 50 + // Pattern binding 51 + let Point(x, y) = point 52 + </code></pre> 53 + <h4>Types and Traits</h4> 54 + <pre><code class="language-Rust">// Type declaration 55 + type Point { 56 + x: f64 57 + y: f64 58 + } 59 + 60 + // Enum (sum type) 61 + type Option[T] { 62 + Some(T) 63 + None 64 + } 65 + 66 + // Trait declaration 67 + trait Display { 68 + fn display(self) -> String 69 + } 70 + 71 + // Generic trait with associated type 72 + trait Container[T] { 73 + type Item 74 + fn get(self) -> Option[T] 75 + fn insert(self, item: T) 76 + } 77 + </code></pre> 78 + <h2>Control Flow</h2> 79 + <h3>Pattern Matching</h3> 80 + <pre><code class="language-Rust">// Basic match expression using pipeline 81 + let description = value 82 + |> match { 83 + Ok(n) if n > 0 -> "Positive" 84 + Ok(n) if n < 0 -> "Negative" 85 + Ok(0) -> "Zero" 86 + Err(e) -> "Error: {e}" 87 + } 88 + 89 + // Match with complex patterns 90 + let command = input 91 + |> match { 92 + Command.Quit -> exit(0) 93 + Command.Move(x, y) -> move_cursor(x, y) 94 + Command.Text(str) -> insert_text(str) 95 + _ -> beep() 96 + } 97 + </code></pre> 98 + <h3>Conditionals</h3> 99 + <pre><code class="language-Rust">// If expression 100 + let status = if count > 0 { 101 + "Active" 102 + } else { 103 + "Inactive" 104 + } 105 + 106 + // Guard statement for early returns 107 + fn process(data: Option[Data]) -> Result[Output, Error] { 108 + guard let unwrapped = data else { 109 + return Err(Error.InvalidData) 110 + } 111 + process_unwrapped(unwrapped) 112 + } 113 + 114 + </code></pre> 115 + <h3>Loops</h3> 116 + <pre><code class="language-Rust">// For-in loop 117 + for item in items { 118 + process(item) 119 + } 120 + 121 + // While loop 122 + while condition { 123 + // ... 124 + } 125 + 126 + // Loop with iterator methods 127 + items 128 + |> filter(pred) 129 + |> map(transform) 130 + |> collect() 131 + </code></pre> 132 + <h2>Error Handling</h2> 133 + <h3>Results and Options</h3> 134 + <pre><code class="language-Rust">// Using Result type 135 + fn divide(x: f64, y: f64) -> Result[f64, DivisionError] { 136 + if y == 0.0 { 137 + Err(DivisionError.DivideByZero) 138 + } else { 139 + Ok(x / y) 140 + } 141 + } 142 + 143 + // Chaining Results 144 + let result = value 145 + |> first_operation() 146 + |> and_then(second_operation) 147 + |> map(third_operation) 148 + |> map_err(CustomError) 149 + 150 + // Pattern matching on Result 151 + let output = result 152 + |> match { 153 + Ok(value) -> process(value) 154 + Err(e) -> handle_error(e) 155 + } 156 + </code></pre> 157 + <h2>Effects and Side Effects</h2> 158 + <h3>Effect Declaration and Usage</h3> 159 + <pre><code class="language-Rust">// Declaring effects 160 + effect IO { 161 + read_line() -> String 162 + print(str: String) 163 + } 164 + 165 + // Using effects 166 + fn greet() -> String with IO { 167 + print("What's your name?") 168 + let name = read_line() 169 + print("Hello, {name}!") 170 + name 171 + } 172 + 173 + // Handling effects 174 + fn main() { 175 + run with IO = ConsoleIO { 176 + let name = greet() 177 + print("Goodbye, {name}") 178 + } 179 + } 180 + </code></pre> 181 + <h2>Generics and Traits</h2> 182 + <h3>Generic Types</h3> 183 + <pre><code class="language-Rust">// Generic type declaration 184 + type List[T] { 185 + head: Option[T] 186 + tail: Option[Box[List[T]]] 187 + } 188 + 189 + // Generic trait bounds 190 + fn sort[T: Ord](list: &mut [T]) { 191 + // Implementation 192 + } 193 + 194 + // Multiple bounds 195 + fn process[T: Display + Clone](item: T) { 196 + // Implementation 197 + } 198 + </code></pre> 199 + <h3>Trait Implementation</h3> 200 + <pre><code class="language-Rust">implement Display for Point { 201 + fn display(self) -> String { 202 + "Point({self.x}, {self.y})" 203 + } 204 + } 205 + 206 + // Generic implementation 207 + implement[T: Display] Display for Option[T] { 208 + fn display(self) -> String { 209 + match self { 210 + Some(value) -> "Some({value})" 211 + None -> "None" 212 + } 213 + } 214 + } 215 + 216 + </code></pre> 217 + <h2>Concurrency</h2> 218 + <h3>Async/Await</h3> 219 + <pre><code class="language-Rust">// Async function declaration 220 + fn fetch_data(url: String) -> Result[Data, Error] with Async { 221 + let response = http.get(url)?.await 222 + let data = response.json()?.await 223 + Ok(data) 224 + } 225 + 226 + // Using async functions 227 + fn process() with Async { 228 + let data = fetch_data("example.com")? 229 + |> await 230 + process_data(data) 231 + |> await 232 + } 233 + </code></pre> 234 + <h3>Thread Safety</h3> 235 + <pre><code class="language-Rust">// Thread-local by default 236 + let counter = 0 237 + 238 + // Explicitly shared state 239 + shared let global_counter = AtomicInteger(0) 240 + 241 + // Shared function 242 + shared fn increment() { 243 + global_counter.fetch_add(1) 244 + } 245 + </code></pre> 246 + <h2>Pipeline Operator</h2> 247 + <h3>Basic Usage</h3> 248 + <pre><code class="language-Rust">// Pipeline with simple transformations 249 + let result = value 250 + |> transform1() 251 + |> transform2() 252 + |> transform3() 253 + 254 + // Pipeline with closures 255 + let processed = data 256 + |> map(x -> x * 2) 257 + |> filter(x -> x > 0) 258 + |> fold(0, (acc, x) -> acc + x) 259 + </code></pre> 260 + <h3>Complex Pipelines</h3> 261 + <pre><code class="language-Rust">let result = initial_value 262 + |> validate() 263 + |> match { 264 + Ok(value) -> process(value) 265 + Err(e) -> handle_error(e) 266 + } 267 + |> transform() 268 + |> finalize() 269 + </code></pre> 270 + <h2>Standard Library Conventions</h2> 271 + <h3>Iterator Methods</h3> 272 + <pre><code class="language-Rust">// Method chaining with iterators 273 + let sum = numbers 274 + |> filter(n -> n > 0) 275 + |> map(n -> n * n) 276 + |> sum() 277 + 278 + // Collecting results 279 + let vec = iter 280 + |> filter(pred) 281 + |> map(transform) 282 + |> collect() 283 + </code></pre> 284 + <h3>String Formatting</h3> 285 + <pre><code class="language-Rust">// String interpolation 286 + let message = "Hello, {name}!" 287 + 288 + // Multi-line strings 289 + let text = """ 290 + This is a multi-line 291 + string with proper 292 + indentation handling 293 + """ 294 + </code></pre> 295 + <h2>Module System</h2> 296 + <h3>Module Declaration</h3> 297 + <pre><code class="language-Rust">// Module declaration 298 + module math { 299 + pub fn add(x: i32, y: i32) -> i32 { 300 + x + y 301 + } 302 + } 303 + 304 + // Using modules 305 + use math.{add, subtract} 306 + use collections.{HashMap, Vector} 307 + </code></pre> 308 + <h2>Comments and Documentation</h2> 309 + <h3>Documentation Comments</h3> 310 + <pre><code class="language-Rust">/// Function documentation 311 + /// 312 + /// # Arguments 313 + /// * `x` - First number 314 + /// * `y` - Second number 315 + /// 316 + /// # Returns 317 + /// Sum of the two numbers 318 + 319 + fn add(x: i32, y: i32) -> i32 { 320 + x + y 321 + } 322 + 323 + // Regular single-line comment 324 + 325 + /* Block comment 326 + spanning multiple 327 + lines */ 328 + 329 + </code></pre> 330 + <h2>Formatting Rules</h2> 331 + <ol> 332 + <li>Use 4 spaces for indentation</li> 333 + <li>One statement per line</li> 334 + <li>Blank line between function definitions</li> 335 + <li>No semicolon for expressions that are the last in a block</li> 336 + <li>Space after keywords</li> 337 + <li>No space after function names in calls</li> 338 + <li>Align match arms</li> 339 + <li>Pipeline operators at the start of lines</li> 340 + <li>Break long lines at sensible points (pipelines, binary operators)</li> 341 + </ol> 342 + <h2>Best Practices</h2> 343 + <ol> 344 + <li>Prefer pipeline style for transformations and matches</li> 345 + <li>Use pattern matching over if/else chains</li> 346 + <li>Make effects explicit</li> 347 + <li>Keep functions focused and small</li> 348 + <li>Use meaningful and descriptive names</li> 349 + <li>Document public interfaces</li> 350 + <li>Utilize type inference where it aids readability</li> 351 + <li>Make thread sharing explicit</li> 352 + <li>Handle all error cases explicitly</li> 353 + <li>Use appropriate abstraction levels</li> 354 + </ol> 355 + </body> 356 + </html>

+37

essay/entry/Untitled.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Untitled</title> 7 + <link rel="stylesheet" href="..//css/base.css"> 8 + <link rel="stylesheet" href="..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <pre><code class="language-Rust"> 12 + struct Encoder { 13 + 14 + } 15 + 16 + impl Encoder { 17 + fn new(chars: &[char]) --> Self { 18 + Self { 19 + chars, 20 + position: 0, 21 + is_number: false, 22 + number_start: 0 23 + } 24 + } 25 + } 26 + 27 + let chars = {} 28 + 29 + let enc = Encoder::new(chars) 30 + 31 + for char in enc.chars { 32 + 33 + } 34 + 35 + 36 + </code></pre></body> 37 + </html>

+26

essay/entry/todo!.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>todo!</title> 7 + <link rel="stylesheet" href="..//css/base.css"> 8 + <link rel="stylesheet" href="..//css/syntax.css"> 9 + </head> 10 + <body> 11 + <hr /> 12 + kanban-plugin: board 13 + <hr /> 14 + <h2>PLANNED</h2> 15 + <h2>NOT STARTED</h2> 16 + <h2>BLOCKED</h2> 17 + <h2>IN PROGRESS</h2> 18 + <h2>IN TESTING</h2> 19 + <h2>DONE</h2> 20 + Complete 21 + %% kanban:settings 22 + <pre><code>{"kanban-plugin":"board","list-collapse":[true,true,true,true,true,true]} 23 + </code></pre> 24 + %% 25 + </body> 26 + </html>

+24

essay/index.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>Language Overview</title> 7 + <link rel="stylesheet" href="./css/base.css"> 8 + <link rel="stylesheet" href="./css/syntax.css"> 9 + </head> 10 + <body> 11 + <h1>Index</h1> 12 + <ul> 13 + <li><a href="./entry/Language Overview.html">Language Overview.md</a></li> 14 + <li><a href="./entry/Untitled.html">Untitled.md</a></li> 15 + <li><a href="./entry/Logo.html">Logo.svg</a></li> 16 + <li><a href="./entry/todo!.html">todo!.md</a></li> 17 + <li><a href="./entry/Features/Effects.html">Features/Effects.md</a></li> 18 + <li><a href="./entry/Features/Allocator.html">Features/Allocator.md</a></li> 19 + <li><a href="./entry/Features/Traits.html">Features/Traits.md</a></li> 20 + <li><a href="./entry/README.md.html">README.md.md</a></li> 21 + <li><a href="./entry/Syntax Guide.html">Syntax Guide.md</a></li> 22 + </ul> 23 + </body> 24 + </html>

+287

grant_proposal.html

··· 1 + <!DOCTYPE html> 2 + <html lang="en"> 3 + <head> 4 + <meta charset="utf-8"> 5 + <meta name="viewport" content="width=device-width, initial-scale=1"> 6 + <title>grant_proposal</title> 7 + <style> 8 + /* CSS Reset */ 9 + *, *::before, *::after { 10 + box-sizing: border-box; 11 + margin: 0; 12 + padding: 0; 13 + } 14 + 15 + /* CSS Variables */ 16 + :root { 17 + --color-background: #ffffff; 18 + --color-foreground: #2b303b; 19 + --color-link: #0366d6; 20 + --color-link-hover: #0256b8; 21 + 22 + --font-body: IBM Plex, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; 23 + --font-heading: IBM Plex Sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; 24 + --font-mono: 'IBM Plex Mono', 'Berkeley Mono', 'Cascadia Code', 'Roboto Mono', Consolas, monospace; 25 + 26 + --spacing-base: 16px; 27 + --spacing-line-height: 1.6; 28 + --spacing-scale: 1.25; 29 + } 30 + 31 + /* Base Styles */ 32 + html { 33 + font-size: var(--spacing-base); 34 + line-height: var(--spacing-line-height); 35 + } 36 + 37 + body { 38 + font-family: var(--font-body); 39 + color: var(--color-foreground); 40 + background-color: var(--color-background); 41 + max-width: 65ch; 42 + margin: 0 auto; 43 + padding: 2rem 1rem; 44 + } 45 + 46 + /* Typography */ 47 + h1, h2, h3, h4, h5, h6 { 48 + font-family: var(--font-heading); 49 + margin-top: calc(1rem * var(--spacing-scale)); 50 + margin-bottom: 0.5rem; 51 + line-height: 1.2; 52 + } 53 + 54 + h1 { font-size: 2.5rem; } 55 + h2 { font-size: 2rem; } 56 + h3 { font-size: 1.5rem; } 57 + h4 { font-size: 1.25rem; } 58 + h5 { font-size: 1.125rem; } 59 + h6 { font-size: 1rem; } 60 + 61 + p { 62 + margin-bottom: 1rem; 63 + } 64 + 65 + a { 66 + color: var(--color-link); 67 + text-decoration: none; 68 + } 69 + 70 + a:hover { 71 + color: var(--color-link-hover); 72 + text-decoration: underline; 73 + } 74 + 75 + /* Lists */ 76 + ul, ol { 77 + margin-left: 2rem; 78 + margin-bottom: 1rem; 79 + } 80 + 81 + li { 82 + margin-bottom: 0.25rem; 83 + } 84 + 85 + /* Code */ 86 + code { 87 + font-family: var(--font-mono); 88 + background-color: rgba(0, 0, 0, 0.05); 89 + padding: 0.125rem 0.25rem; 90 + border-radius: 3px; 91 + font-size: 0.9em; 92 + } 93 + 94 + pre { 95 + overflow-x: auto; 96 + margin-bottom: 1rem; 97 + } 98 + 99 + pre code { 100 + display: block; 101 + padding: 1rem; 102 + background-color: rgba(0, 0, 0, 0.03); 103 + border-radius: 5px; 104 + } 105 + 106 + /* Math */ 107 + .math { 108 + font-family: var(--font-mono); 109 + } 110 + 111 + .math-display { 112 + display: block; 113 + margin: 1rem 0; 114 + text-align: center; 115 + } 116 + 117 + /* Blockquotes */ 118 + blockquote { 119 + border-left: 4px solid var(--color-link); 120 + padding-left: 1rem; 121 + margin: 1rem 0; 122 + font-style: italic; 123 + } 124 + 125 + /* Tables */ 126 + table { 127 + border-collapse: collapse; 128 + width: 100%; 129 + margin-bottom: 1rem; 130 + } 131 + 132 + th, td { 133 + border: 1px solid rgba(0, 0, 0, 0.1); 134 + padding: 0.5rem; 135 + text-align: left; 136 + } 137 + 138 + th { 139 + background-color: rgba(0, 0, 0, 0.05); 140 + font-weight: 600; 141 + } 142 + 143 + /* Footnotes */ 144 + .footnote-reference { 145 + font-size: 0.8em; 146 + } 147 + 148 + .footnote-definition { 149 + margin-top: 2rem; 150 + padding-top: 0.5rem; 151 + border-top: 1px solid rgba(0, 0, 0, 0.1); 152 + font-size: 0.9em; 153 + } 154 + 155 + .footnote-definition-label { 156 + font-weight: 600; 157 + margin-right: 0.5rem; 158 + } 159 + 160 + /* Horizontal Rule */ 161 + hr { 162 + border: none; 163 + border-top: 1px solid rgba(0, 0, 0, 0.1); 164 + margin: 2rem 0; 165 + } 166 + </style> 167 + <style> 168 + /* 169 + * theme "Rosé Pine" generated by syntect 170 + */ 171 + 172 + .wvrcode-code { 173 + color: #e0def4; 174 + background-color: #191724; 175 + } 176 + 177 + .wvrcode-comment { 178 + color: #908caa; 179 + font-style: italic; 180 + } 181 + .wvrcode-string, .wvrcode-punctuation.wvrcode-definition.wvrcode-string { 182 + color: #f6c177; 183 + } 184 + .wvrcode-constant.wvrcode-numeric { 185 + color: #f6c177; 186 + } 187 + .wvrcode-constant.wvrcode-language { 188 + color: #f6c177; 189 + font-weight: bold; 190 + } 191 + .wvrcode-constant.wvrcode-character, .wvrcode-constant.wvrcode-other { 192 + color: #f6c177; 193 + } 194 + .wvrcode-variable { 195 + color: #e0def4; 196 + font-style: italic; 197 + } 198 + .wvrcode-keyword { 199 + color: #31748f; 200 + } 201 + .wvrcode-storage { 202 + color: #9ccfd8; 203 + } 204 + .wvrcode-storage.wvrcode-type { 205 + color: #9ccfd8; 206 + } 207 + .wvrcode-entity.wvrcode-name.wvrcode-class { 208 + color: #31748f; 209 + font-weight: bold; 210 + } 211 + .wvrcode-entity.wvrcode-other.wvrcode-inherited-class { 212 + color: #31748f; 213 + font-style: italic; 214 + } 215 + .wvrcode-entity.wvrcode-name.wvrcode-function { 216 + color: #ebbcba; 217 + font-style: italic; 218 + } 219 + .wvrcode-variable.wvrcode-parameter { 220 + color: #c4a7e7; 221 + } 222 + .wvrcode-entity.wvrcode-name.wvrcode-tag { 223 + color: #31748f; 224 + font-weight: bold; 225 + } 226 + .wvrcode-entity.wvrcode-other.wvrcode-attribute-name { 227 + color: #c4a7e7; 228 + } 229 + .wvrcode-support.wvrcode-function { 230 + color: #ebbcba; 231 + font-weight: bold; 232 + } 233 + .wvrcode-support.wvrcode-constant { 234 + color: #f6c177; 235 + font-weight: bold; 236 + } 237 + .wvrcode-support.wvrcode-type, .wvrcode-support.wvrcode-class { 238 + color: #9ccfd8; 239 + font-weight: bold; 240 + } 241 + .wvrcode-support.wvrcode-other.wvrcode-variable { 242 + color: #eb6f92; 243 + font-weight: bold; 244 + } 245 + .wvrcode-invalid { 246 + color: #e0def4; 247 + background-color: #eb6f92; 248 + } 249 + .wvrcode-invalid.wvrcode-deprecated { 250 + color: #e0def4; 251 + background-color: #c4a7e7; 252 + } 253 + .wvrcode-punctuation, .wvrcode-keyword.wvrcode-operator { 254 + color: #908caa; 255 + } 256 + </style> 257 + </head> 258 + <body> 259 + <h1>In a short paragraph, tell us about your project and what you're building.</h1> 260 + Weaver is designed to be a highly flexible platform for medium and long-form writing on atproto. I was inspired by how weaver birds build their own homes, and by the notebooks, physical and virtual, that I create in the course of my work, to ideate, to document, and to inform. The initial proof-of-concept is a static site generator, able to turn a Markdown text file or a folder of Markdown files, such as an Obsidian vault or git repository documentation, into a static "notebook" site. The file is uploaded to your PDS, where it can be accessed, either directly, via a minimal appview layer that provides a friendlier web address than an XRPC request or CDN link, or hosted on a platform of your choice, be that your own server or any other static site hosting service. The intermediate goal is an elegant and intuitive writing platform with collaborative editing and straightforward, immediate publishing via a web-app. The ultimate goal is to build a platform suitable for professional writers and journalists, an open alternative to platforms like Substack, with ways for readers to support writers, all on the AT protocol. Currently it is in the earliest stages of development, working on core components such as the parsing and rendering backend, command-line client, and initial appview. The plan is to have the proof-of-concept ready for testing in June, and to immediately begin using it for my own writing, as well as information and updates about the project. 261 + <h1>How do you plan to use this grant? Feel free to be specific.</h1> 262 + I plan to use the grant money to help with hosting and/or hardware costs (such as VPS rental fees or upgrades to my homelab, like a backup internet connection), and potentially to offset the costs of incorporation. If I'm not able to dedicate enough time to this or bring other people onto the project, it won't get off the ground, and some help with expenses makes that possible. 263 + <h1>Who are you? Please provide a brief bio or background about yourself.</h1> 264 + I'm Orual, an electronics designer and software engineer who routinely works across the entire stack from bare metal microcontrollers all the way up to web services, UX development, and AI. I grew up getting mail delivered by single-engine Cessna airplane to a grass airstrip outside a tiny village in Congo and listening to my parents talk with people half-way across the country on a short-wave radio, later using an early satellite phone to send email, the ultimate decentralized information network, maybe. I wrote my first line of code when I was ten, started building robots soon after, got into university for engineering, designed and built electronic musical instruments, dropped out of university, transitioned my sex, learned a ton about programming and electronics, went back to college and got into research. 265 + Currently, I work part-time as a principal investigator in a small applied research lab at a college, helping startups and other businesses with product development and prototyping. I'm a long-time enthusiast for blogging and other forms of extended online writing, but have always been dissatisfied with existing solutions, which is the impetus for Weaver, and because of my experience across the whole tech stack, I think I can deliver something really great. 266 + <h1>What excites you about building in the ATProto/Bluesky ecosystem? This helps us understand what's driving you.</h1> 267 + I'm a Utopian in the Terra Ignota sense. I want to see us flourish and go out into the universe. I want people to be free and able to create and build wonders, not beholden to any sovereigns, in whatever forms they wish. My vocation is engineering. It is the thing I cannot help but do, and I take great pleasure and pride in it. In the ATProto ecosystem I see a way to direct my skills toward creating the kinds of tools and platforms that empower people. 268 + I got onto Bluesky early and was immediately hooked for a number of reasons. The first is the actual protocol itself. How it does identity, how the user maintains control over their identity and data, largely independent of hosting and services, and how no single service needs to do it all, you can mix and match. It's the embodiment of a lot of the ideas I've had about how the social web should work for a long time. 269 + In addition to championing the atproto identity model and overall philosophy to clients at work, I’ve done some early explorations with private data and varied interaction modalities via embedded systems, such as a Rust XRPC client for microcontrollers like the ESP32. I've been watching projects like Whitewind and Leaflet explore the long-form atproto writing space, and I think there's room for a more flexible, extensible, and collaborative approach to the concept on the protocol. 270 + The other primary staying factor has been the community. The Bluesky dev team has been so enthusiastic and welcoming for those who want to work on and with the protocol. One personal example is that of Morpho, an Android Bluesky client, which received an ATProtocol microgrant. I’ve made a lot of friends on Bluesky, and I want to grow the ecosystem which allowed that to happen, to help it flourish and become more than just a grand dream behind a Twitter clone. 271 + <h1>How does your project align with our goal of accelerating growth in the ATProto/Bluesky ecosystem with developer tools?</h1> 272 + The initial alpha version of Weaver is targeted at developers and people otherwise comfortable with a terminal. It aims to bring the process of documenting your tools, educating people, and otherwise writing and publishing things that don’t fit well into a Bluesky post or thread onto the protocol in a way that is highly flexible. If that is all that it does, that’s excellent and meets a need that I see in the community. It would provide a consistent way to make a blog built on ATProto without everyone having to reinvent part or all of the wheel, or do programming they don't want to do. 273 + As Weaver develops further and targets a less technical audience, it will retain those more developer-focused modes of use, for people who want to do something more specialized with it, have a workflow they like which doesn’t mesh with the web editor (and if they want to write their own tooling on top of Weaver, more power to them), or just want to run it all themselves. Developers are also the initial audience because the alpha will inevitably be rough around the edges, and nobody provides quality feedback like other developers. 274 + <h1>How does your project align with our goal of empowering communities with the tools to cultivate and sustain themselves?</h1> 275 + Communities don’t just need microblogging posts and algorithmic feeds. They need places for longer-form content, less ephemeral works they can point to; stories, essays, rules, histories, articles, and so on. One of the biggest downsides of so many companies and communities moving onto closed platforms like Discord was the lack of durability of any content by default and the inability to easily access and search it from outside the platform, and one of the downsides of “identity-follower”-based platforms like Bluesky (where relationships are about following specific people) is that they produce communities highly focused on specific people as much as specific topics or interests. Weaver notebooks and entries within them can be throwaways, but they’re intended to stick around and remain accessible in a consistent way (unless taken down). 276 + There’s a need for better tools for that kind of thing on the protocol right now, as currently a lot of stuff is bespoke, feels incomplete as an experience, or is just not really connected to the protocol and so misses on some of the data ownership of ATProto. 277 + One aspect which makes Weaver as designed good for communities is simply that, unlike with Bluesky, where a follower is a follower and you only have one identity, you can have more than one notebook (and they can be shared between multiple authors), and more than one author profile. Someone might make a personal blog, or one for a project, or to write a piece of web fiction with a friend, either all under the same profile or under different ones, as fits their wants and needs. People have different contextual identities but don’t necessarily want to make alt accounts, and a writing platform for people should reflect that. 278 + Collaborative editing is a great feature for communities as well. People can workshop something with their friends and then publish it instantly. You could build a wiki for a fandom community on Weaver. Two journalists could publish a newsletter together, and bring on an editor to tighten up their articles. And over time, Weaver would ultimately support payments, helping creators fund their work. 279 + <h1>How does your project align with our goal of giving people direct, unmediated access to their audiences?</h1> 280 + The first and maybe most powerful thing I’m going to give people that sort of direct and durable access is building complete self-hosting into it from day 1, inverting the pattern Bluesky followed. Weaver is designed to outlive Bluesky and even to some extent the AT Protocol. The failure mode is much the same as a tool like Obsidian, which is a direct inspiration. Because the core document format is Markdown, which is fundamentally just a text file you can load up in any editor, and the basic tools are designed to work without any ATProto authentication, people can keep using them and easily port or host the contents however they wish. You can go where your audience is. 281 + Beyond that, the platform features are all about making the process of writing something and putting it out there for people to read as simple as possible, in a way that means you have ownership of that data, the same as anything else on the protocol, Even when collaborating on a document, you retain control, via much the same means that each person's repository uses to maintain consistency. And since it's designed to interoperate widely, you can easily bring notebooks and entries from Weaver to your audience on Bluesky or any other ATProto platform, and they can comment on them from Bluesky. 282 + <h1>Other things to share?</h1> 283 + Here's a bit more technical detail on what will underpin the collaborative features. A notebook entry on the protocol is a type of CRDT, a conflict-free replicated data type, built on top of Loro, stored as a series of your edit records on top of a root record in your own repository (with others’ edit records being stored in their own repositories), along with the contents of the most recently seen (and most recently published) versions. 284 + With the combination of those pieces, if one person deletes a notebook or entry, everyone else in the list of authors retains the contents and can recreate most of the edit history, even if the Weaver appview doesn't have the deleted records cached. 285 + The appview itself is a couple of components. One is a lightweight entryway service, which mostly provides that friendly external url for published notebooks, redirecting to an author's PDS or a CDN and handling some authentication (e.g. to ensure that, while an unpublished or controlled-audience notebook or entry does exist in one's PDS unencrypted, one cannot just navigate to it). The second component is the backend for the collaborative features and will host the web-based editing and navigation interface. All of this is designed to be used or run independently if desired. 286 + </body> 287 + </html>