From cd6898439e9de6fce42555e2bab5c27e206dbcde Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 12:17:13 +0000
Subject: [PATCH 01/37] Comment out `link_section` on procedures

---
 core/runtime/entry_unix.odin | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/runtime/entry_unix.odin b/core/runtime/entry_unix.odin
index 67d2cbcb7..dd1e06625 100644
--- a/core/runtime/entry_unix.odin
+++ b/core/runtime/entry_unix.odin
@@ -5,13 +5,13 @@ package runtime
 import "core:intrinsics"
 
 when ODIN_BUILD_MODE == .Dynamic {
-	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
+	@(link_name="_odin_entry_point", linkage="strong", require/*, link_section=".init"*/)
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _startup_runtime()
 		intrinsics.__entry_point()
 	}
-	@(link_name="_odin_exit_point", linkage="strong", require, link_section=".fini")
+	@(link_name="_odin_exit_point", linkage="strong", require/*, link_section=".fini"*/)
 	_odin_exit_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _cleanup_runtime()

From 686dbb4421824f17164443b2538b587e91d400a5 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 14:43:42 +0000
Subject: [PATCH 02/37] Correct odin doc comment printing

---
 src/docs.cpp        | 28 ++++++++++++++++++++++------
 src/docs_writer.cpp |  5 +++--
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/docs.cpp b/src/docs.cpp
index 8d65cb83a..3ea3cce1b 100644
--- a/src/docs.cpp
+++ b/src/docs.cpp
@@ -67,6 +67,14 @@ GB_COMPARE_PROC(cmp_ast_package_by_name) {
 #include "docs_format.cpp"
 #include "docs_writer.cpp"
 
+void print_doc_line(i32 indent, String const &data) {
+	while (indent --> 0) {
+		gb_printf("\t");
+	}
+	gb_file_write(gb_file_get_standard(gbFileStandard_Output), data.text, data.len);
+	gb_printf("\n");
+}
+
 void print_doc_line(i32 indent, char const *fmt, ...) {
 	while (indent --> 0) {
 		gb_printf("\t");
@@ -86,6 +94,13 @@ void print_doc_line_no_newline(i32 indent, char const *fmt, ...) {
 	gb_printf_va(fmt, va);
 	va_end(va);
 }
+void print_doc_line_no_newline(i32 indent, String const &data) {
+	while (indent --> 0) {
+		gb_printf("\t");
+	}
+	gb_file_write(gb_file_get_standard(gbFileStandard_Output), data.text, data.len);
+}
+
 
 bool print_doc_comment_group_string(i32 indent, CommentGroup *g) {
 	if (g == nullptr) {
@@ -106,8 +121,9 @@ bool print_doc_comment_group_string(i32 indent, CommentGroup *g) {
 		String comment = g->list[i].string;
 		String original_comment = comment;
 
-		bool slash_slash = comment[1] == '/';
+		bool slash_slash = false;
 		if (comment[1] == '/') {
+			slash_slash = true;
 			comment.text += 2;
 			comment.len  -= 2;
 		} else if (comment[1] == '*') {
@@ -131,7 +147,7 @@ bool print_doc_comment_group_string(i32 indent, CommentGroup *g) {
 		}
 
 		if (slash_slash) {
-			print_doc_line(indent, "%.*s", LIT(comment));
+			print_doc_line(indent, comment);
 			count += 1;
 		} else {
 			isize pos = 0;
@@ -143,7 +159,7 @@ bool print_doc_comment_group_string(i32 indent, CommentGroup *g) {
 					}
 				}
 				String line = substring(comment, pos, end);
-				pos = end+1;
+				pos = end;
 				String trimmed_line = string_trim_whitespace(line);
 				if (trimmed_line.len == 0) {
 					if (count == 0) {
@@ -159,7 +175,7 @@ bool print_doc_comment_group_string(i32 indent, CommentGroup *g) {
 					line = substring(line, 2, line.len);
 				}
 
-				print_doc_line(indent, "%.*s", LIT(line));
+				print_doc_line(indent, line);
 				count += 1;
 			}
 		}
@@ -263,7 +279,7 @@ void print_doc_package(CheckerInfo *info, AstPackage *pkg) {
 			}
 			GB_ASSERT(type_expr != nullptr || init_expr != nullptr);
 
-			print_doc_line_no_newline(2, "%.*s", LIT(e->token.string));
+			print_doc_line_no_newline(2, e->token.string);
 			if (type_expr != nullptr) {
 				gbString t = expr_to_string(type_expr);
 				gb_printf(": %s ", t);
@@ -298,7 +314,7 @@ void print_doc_package(CheckerInfo *info, AstPackage *pkg) {
 		for_array(i, pkg->files) {
 			AstFile *f = pkg->files[i];
 			String filename = remove_directory_from_path(f->fullpath);
-			print_doc_line(2, "%.*s", LIT(filename));
+			print_doc_line(2, filename);
 		}
 	}
 
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index 56ad0561e..94b43be99 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -292,8 +292,9 @@ bool odin_doc_append_comment_group_string(Array<u8> *buf, CommentGroup *g) {
 		String comment = g->list[i].string;
 		String original_comment = comment;
 
-		bool slash_slash = comment[1] == '/';
+		bool slash_slash = false;
 		if (comment[1] == '/') {
+			slash_slash = true;
 			comment.text += 2;
 			comment.len  -= 2;
 		} else if (comment[1] == '*') {
@@ -330,7 +331,7 @@ bool odin_doc_append_comment_group_string(Array<u8> *buf, CommentGroup *g) {
 					}
 				}
 				String line = substring(comment, pos, end);
-				pos = end+1;
+				pos = end;
 				String trimmed_line = string_trim_whitespace(line);
 				if (trimmed_line.len == 0) {
 					if (count == 0) {

From 76ccce2942a0d527be5693ff5bedbf92a5de5eb2 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 17:57:55 +0000
Subject: [PATCH 03/37] Begin work on a html doc printer

---
 tools/odin-html-docs/odin_html_docs_main.odin | 609 ++++++++++++++++++
 tools/odin-html-docs/style.css                |  31 +
 2 files changed, 640 insertions(+)
 create mode 100644 tools/odin-html-docs/odin_html_docs_main.odin
 create mode 100644 tools/odin-html-docs/style.css

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
new file mode 100644
index 000000000..7c822e4a1
--- /dev/null
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -0,0 +1,609 @@
+package odin_html_docs
+
+import doc "core:odin/doc-format"
+import "core:fmt"
+import "core:io"
+import "core:os"
+import "core:strings"
+import "core:path/slashpath"
+import "core:sort"
+import "core:slice"
+
+header:   ^doc.Header
+files:    []doc.File
+pkgs:     []doc.Pkg
+entities: []doc.Entity
+types:    []doc.Type
+
+pkgs_to_use: map[string]^doc.Pkg // trimmed path
+pkg_to_path: map[^doc.Pkg]string // trimmed path
+
+array :: proc(a: $A/doc.Array($T)) -> []T {
+	return doc.from_array(header, a)
+}
+str :: proc(s: $A/doc.String) -> string {
+	return doc.from_string(header, s)
+}
+
+errorf :: proc(format: string, args: ..any) -> ! {
+	fmt.eprintf("%s ", os.args[0])
+	fmt.eprintf(format, ..args)
+	fmt.eprintln()
+	os.exit(1)
+}
+
+common_prefix :: proc(strs: []string) -> string {
+	if len(strs) == 0 {
+		return ""
+	}
+	n := max(int)
+	for str in strs {
+		n = min(n, len(str))
+	}
+
+	prefix := strs[0][:n]
+	for str in strs[1:] {
+		for len(prefix) != 0 && str[:len(prefix)] != prefix {
+			prefix = prefix[:len(prefix)-1]
+		}
+		if len(prefix) == 0 {
+			break
+		}
+	}
+	return prefix
+}
+
+
+write_html_header :: proc(w: io.Writer, title: string) {
+	fmt.wprintf(w, `<!DOCTYPE html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<title>%s</title>
+
+	<script type="text/javascript" src="https://livejs.com/live.js"></script>
+	<link rel="stylesheet" type="text/css" href="/style.css">
+
+	</style>
+</head>
+<body>`, title)
+	fmt.wprintln(w, "\n<div class=\"container\">")
+	fmt.wprintln(w, "\n<a href=\"/core\">Core Directory</a>")
+
+}
+
+write_html_footer :: proc(w: io.Writer) {
+	fmt.wprintf(w, "</div></body>\n</html>\n")
+}
+
+main :: proc() {
+	if len(os.args) != 2 {
+		errorf("expected 1 .odin-doc file")
+	}
+	data, ok := os.read_entire_file(os.args[1])
+	if !ok {
+		errorf("unable to read file:", os.args[1])
+	}
+	err: doc.Reader_Error
+	header, err = doc.read_from_bytes(data)
+	switch err {
+	case .None:
+	case .Header_Too_Small:
+		errorf("file is too small for the file format")
+	case .Invalid_Magic:
+		errorf("invalid magic for the file format")
+	case .Data_Too_Small:
+		errorf("data is too small for the file format")
+	case .Invalid_Version:
+		errorf("invalid file format version")
+	}
+	files    = array(header.files)
+	pkgs     = array(header.pkgs)
+	entities = array(header.entities)
+	types    = array(header.types)
+
+	fullpaths: [dynamic]string
+	defer delete(fullpaths)
+
+	for pkg in pkgs[1:] {
+		append(&fullpaths, str(pkg.fullpath))
+	}
+	path_prefix := common_prefix(fullpaths[:])
+
+	pkgs_to_use = make(map[string]^doc.Pkg)
+	for fullpath, i in fullpaths {
+		path := strings.trim_prefix(fullpath, path_prefix)
+		if strings.has_prefix(path, "core/") {
+			pkgs_to_use[strings.trim_prefix(path, "core/")] = &pkgs[i+1]
+		}
+	}
+	sort.map_entries_by_key(&pkgs_to_use)
+	for path, pkg in pkgs_to_use {
+		pkg_to_path[pkg] = path
+	}
+
+	b := strings.make_builder()
+	w := strings.to_writer(&b)
+	{
+		strings.reset_builder(&b)
+		write_html_header(w, "core library - pkg.odin-lang.org")
+		write_core_directory(w)
+		write_html_footer(w)
+		os.make_directory("core", 0)
+		os.write_entire_file("core/index.html", b.buf[:])
+	}
+
+	for path, pkg in pkgs_to_use {
+		strings.reset_builder(&b)
+		write_html_header(w, fmt.tprintf("package %s - pkg.odin-lang.org", path))
+		write_pkg(w, path, pkg)
+		write_html_footer(w)
+		os.make_directory(fmt.tprintf("core/%s", path), 0)
+		os.write_entire_file(fmt.tprintf("core/%s/index.html", path), b.buf[:])
+	}
+}
+
+
+write_core_directory :: proc(w: io.Writer) {
+	Node :: struct {
+		dir: string,
+		path: string,
+		name: string,
+		pkg: ^doc.Pkg,
+		next: ^Node,
+		first_child: ^Node,
+	}
+	add_child :: proc(parent: ^Node, child: ^Node) -> ^Node {
+		assert(parent != nil)
+		end := &parent.first_child
+		for end^ != nil {
+			end = &end^.next
+		}
+		child.next = end^
+		end^ = child
+		return child
+	}
+
+	root: Node
+	for path, pkg in pkgs_to_use {
+		dir, _, inner := strings.partition(path, "/")
+
+		node: ^Node = nil
+		for node = root.first_child; node != nil; node = node.next {
+			if node.dir == dir {
+				break
+			}
+		}
+		if inner == "" {
+			if node == nil {
+				add_child(&root, new_clone(Node{
+					dir  = dir,
+					name = dir,
+					path = path,
+					pkg  = pkg,
+				}))
+			} else {
+				node.dir  = dir
+				node.name = dir
+				node.path = path
+				node.pkg  = pkg
+			}
+		} else {
+			if node == nil {
+				node = add_child(&root, new_clone(Node{
+					dir  = dir,
+					name = dir,
+				}))
+			}
+			assert(node != nil)
+			child := add_child(node, new_clone(Node{
+				dir  = dir,
+				name = inner,
+				path = path,
+				pkg  = pkg,
+			}))
+		}
+	}
+
+
+	fmt.wprintln(w, "<h2>Directories</h2>")
+
+	fmt.wprintln(w, "\t<table>")
+	fmt.wprintln(w, "\t\t<tbody>")
+
+	for dir := root.first_child; dir != nil; dir = dir.next {
+		if dir.first_child != nil {
+			fmt.wprint(w, `<tr aria-controls="`)
+			for child := dir.first_child; child != nil; child = child.next {
+				fmt.wprintf(w, "pkg-%s ", str(child.pkg.name))
+			}
+			fmt.wprint(w, `" class="directory-pkg"><td class="pkg-name" data-aria-owns="`)
+			for child := dir.first_child; child != nil; child = child.next {
+				fmt.wprintf(w, "pkg-%s ", str(child.pkg.name))
+			}
+			fmt.wprintf(w, `" id="pkg-%s">`, dir.dir)
+		} else {
+			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg"><td class="pkg-name">`, dir.dir)
+		}
+
+		if dir.pkg != nil {
+			fmt.wprintf(w, `<a href="/core/%s">%s</a>`, dir.path, dir.name)
+		} else {
+			fmt.wprintf(w, "%s", dir.name)
+		}
+		fmt.wprintf(w, "</td>")
+		if dir.pkg != nil {
+			line_doc, _, _ := strings.partition(str(dir.pkg.docs), "\n")
+			line_doc = strings.trim_space(line_doc)
+			if line_doc != "" {
+				fmt.wprintf(w, `<td class="pkg-line-doc">%s</td>`, line_doc)
+			}
+		}
+		fmt.wprintf(w, "</tr>\n")
+
+		for child := dir.first_child; child != nil; child = child.next {
+			assert(child.pkg != nil)
+			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg directory-child"><td class="pkg-name">`, str(child.pkg.name))
+			fmt.wprintf(w, `<a href="/core/%s/">%s</a>`, child.path, child.name)
+			fmt.wprintf(w, "</td>")
+
+			line_doc, _, _ := strings.partition(str(child.pkg.docs), "\n")
+			line_doc = strings.trim_space(line_doc)
+			if line_doc != "" {
+				fmt.wprintf(w, `<td class="pkg-line-doc">%s</td>`, line_doc)
+			}
+
+			fmt.wprintf(w, "</tr>\n")
+		}
+	}
+
+	fmt.wprintln(w, "\t\t</tbody>")
+	fmt.wprintln(w, "\t</table>")
+}
+
+is_entity_blank :: proc(e: doc.Entity_Index) -> bool {
+	name := str(entities[e].name)
+	return name == "" || name == "_"
+}
+
+Write_Type_Flag :: enum {
+	Is_Results,
+	Variadic,
+}
+Write_Type_Flags :: distinct bit_set[Write_Type_Flag]
+
+write_type :: proc(w: io.Writer, pkg: doc.Pkg_Index, type: doc.Type, flags: Write_Type_Flags) {
+	type_entites := array(type.entities)
+	type_types := array(type.types)
+	switch type.kind {
+	case .Invalid:
+		// ignore
+	case .Basic:
+		type_flags := transmute(doc.Type_Flags_Basic)type.flags
+		if .Untyped in type_flags {
+			io.write_string(w, str(type.name))
+		} else {
+			fmt.wprintf(w, `<a href="">%s</a>`, str(type.name))
+		}
+	case .Named:
+		e := entities[type_entites[0]]
+		name := str(type.name)
+		fmt.wprintf(w, `<span>`)
+		tn_pkg := files[e.pos.file].pkg
+		if tn_pkg != pkg {
+			fmt.wprintf(w, `%s.`, str(pkgs[pkg].name))
+		}
+		fmt.wprintf(w, `<a href="/core/{0:s}/#{1:s}">{1:s}</a></span>`, pkg_to_path[&pkgs[tn_pkg]], name)
+	case .Generic:
+		name := str(type.name)
+		io.write_byte(w, '$')
+		io.write_string(w, name)
+		if len(array(type.types)) == 1 {
+			io.write_byte(w, '/')
+			write_type(w, pkg, types[type_types[0]], flags)
+		}
+	case .Pointer:
+		io.write_byte(w, '^')
+		write_type(w, pkg, types[type_types[0]], flags)
+	case .Array:
+		assert(type.elem_count_len == 1)
+		io.write_byte(w, '[')
+		io.write_uint(w, uint(type.elem_counts[0]))
+		io.write_byte(w, ']')
+		write_type(w, pkg, types[type_types[0]], flags)
+	case .Enumerated_Array:
+		io.write_byte(w, '[')
+		write_type(w, pkg, types[type_types[0]], flags)
+		io.write_byte(w, ']')
+		write_type(w, pkg, types[type_types[1]], flags)
+	case .Slice:
+		if .Variadic in flags {
+			io.write_string(w, "..")
+		} else {
+			io.write_string(w, "[]")
+		}
+		write_type(w, pkg, types[type_types[0]], flags - {.Variadic})
+	case .Dynamic_Array:
+		io.write_string(w, "[dynamic]")
+		write_type(w, pkg, types[type_types[0]], flags)
+	case .Map:
+		io.write_string(w, "map[")
+		write_type(w, pkg, types[type_types[0]], flags)
+		io.write_byte(w, ']')
+		write_type(w, pkg, types[type_types[1]], flags)
+	case .Struct:
+		type_flags := transmute(doc.Type_Flags_Struct)type.flags
+		io.write_string(w, "struct {}")
+	case .Union:
+		type_flags := transmute(doc.Type_Flags_Union)type.flags
+		io.write_string(w, "union {}")
+	case .Enum:
+		io.write_string(w, "enum {}")
+	case .Tuple:
+		entity_indices := type_entites
+		if len(entity_indices) == 0 {
+			return
+		}
+		require_parens := (.Is_Results in flags) && (len(entity_indices) > 1 || !is_entity_blank(entity_indices[0]))
+		if require_parens { io.write_byte(w, '(') }
+		for entity_index, i in entity_indices {
+			e := &entities[entity_index]
+			name := str(e.name)
+
+			if i > 0 {
+				io.write_string(w, ", ")
+			}
+			if .Param_Using     in e.flags { io.write_string(w, "using ")      }
+			if .Param_Const     in e.flags { io.write_string(w, "#const ")     }
+			if .Param_Auto_Cast in e.flags { io.write_string(w, "#auto_cast ") }
+			if .Param_CVararg   in e.flags { io.write_string(w, "#c_vararg ")  }
+			if .Param_No_Alias  in e.flags { io.write_string(w, "#no_alias ")  }
+			if .Param_Any_Int   in e.flags { io.write_string(w, "#any_int ")   }
+
+			if name != "" {
+				io.write_string(w, name)
+				io.write_string(w, ": ")
+			}
+			param_flags := flags - {.Is_Results}
+			if .Param_Ellipsis in e.flags {
+				param_flags += {.Variadic}
+			}
+			write_type(w, pkg, types[e.type], param_flags)
+		}
+		if require_parens { io.write_byte(w, ')') }
+
+	case .Proc:
+		type_flags := transmute(doc.Type_Flags_Proc)type.flags
+		io.write_string(w, "proc")
+		cc := str(type.calling_convention)
+		if cc != "" {
+			io.write_byte(w, ' ')
+			io.write_quoted_string(w, cc)
+			io.write_byte(w, ' ')
+		}
+		params := array(type.types)[0]
+		results := array(type.types)[1]
+		io.write_byte(w, '(')
+		write_type(w, pkg, types[params], flags)
+		io.write_byte(w, ')')
+		if results != 0 {
+			assert(.Diverging not_in type_flags)
+			io.write_string(w, " -> ")
+			write_type(w, pkg, types[results], flags+{.Is_Results})
+		}
+		if .Diverging in type_flags {
+			io.write_string(w, " -> !")
+		}
+		if .Optional_Ok in type_flags {
+			io.write_string(w, " #optional_ok")
+		}
+
+	case .Bit_Set:
+		type_flags := transmute(doc.Type_Flags_Bit_Set)type.flags
+	case .Simd_Vector:
+		io.write_string(w, "#simd[")
+		io.write_uint(w, uint(type.elem_counts[0]))
+		io.write_byte(w, ']')
+	case .SOA_Struct_Fixed:
+		io.write_string(w, "#soa[")
+		io.write_uint(w, uint(type.elem_counts[0]))
+		io.write_byte(w, ']')
+	case .SOA_Struct_Slice:
+		io.write_string(w, "#soa[]")
+	case .SOA_Struct_Dynamic:
+		io.write_string(w, "#soa[dynamic]")
+	case .Relative_Pointer:
+		io.write_string(w, "#relative(")
+		write_type(w, pkg, types[type_types[1]], flags)
+		io.write_string(w, ") ")
+		write_type(w, pkg, types[type_types[0]], flags)
+	case .Relative_Slice:
+		io.write_string(w, "#relative(")
+		write_type(w, pkg, types[type_types[1]], flags)
+		io.write_string(w, ") ")
+		write_type(w, pkg, types[type_types[0]], flags)
+	case .Multi_Pointer:
+		io.write_string(w, "[^]")
+		write_type(w, pkg, types[type_types[0]], flags)
+	case .Matrix:
+		io.write_string(w, "matrix[")
+		io.write_uint(w, uint(type.elem_counts[0]))
+		io.write_string(w, ", ")
+		io.write_uint(w, uint(type.elem_counts[1]))
+		io.write_string(w, "]")
+		write_type(w, pkg, types[type_types[0]], flags)
+	}
+}
+
+write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
+	if docs == "" {
+		return
+	}
+	it := docs
+	was_code := true
+	was_paragraph := true
+	for line in strings.split_iterator(&it, "\n") {
+		if strings.has_prefix(line, "\t") {
+			if !was_code {
+				was_code = true;
+				fmt.wprint(w, `<pre class="doc-code"><code>`)
+			}
+			fmt.wprintf(w, "%s\n", strings.trim_prefix(line, "\t"))
+			continue
+		} else if was_code {
+			was_code = false
+			fmt.wprintln(w, "</code></pre>")
+		}
+		text := strings.trim_space(line)
+		if text == "" {
+			if was_paragraph {
+				was_paragraph = false
+				fmt.wprintln(w, "</p>")
+			}
+			continue
+		}
+		if !was_paragraph {
+			fmt.wprintln(w, "<p>")
+		}
+		assert(!was_code)
+		was_paragraph = true
+		fmt.wprintln(w, text)
+	}
+	if was_code {
+		// assert(!was_paragraph, str(pkg.name))
+		was_code = false
+		fmt.wprintln(w, "</code>")
+	} else if was_paragraph {
+		fmt.wprintln(w, "</p>")
+	}
+}
+
+write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
+	fmt.wprintf(w, "<h1>package core:%s</h1>\n", path)
+	fmt.wprintln(w, "<h2>Documentation</h2>")
+	docs := strings.trim_space(str(pkg.docs))
+	if docs != "" {
+		fmt.wprintln(w, "<h3>Overview</h3>")
+		fmt.wprintln(w, "<div id=\"pkg-overview\">")
+		defer fmt.wprintln(w, "</div>")
+
+		write_docs(w, pkg, docs)
+	}
+
+	fmt.wprintln(w, "<h3>Index</h3>")
+	fmt.wprintln(w, `<section class="documentation-index">`)
+	pkg_procs:       [dynamic]^doc.Entity
+	pkg_proc_groups: [dynamic]^doc.Entity
+	pkg_types:       [dynamic]^doc.Entity
+	pkg_vars:        [dynamic]^doc.Entity
+	pkg_consts:      [dynamic]^doc.Entity
+
+	for entity_index in array(pkg.entities) {
+		e := &entities[entity_index]
+		name := str(e.name)
+		if name == "" || name[0] == '_' {
+			continue
+		}
+		switch e.kind {
+		case .Invalid, .Import_Name, .Library_Name:
+			// ignore
+		case .Constant:   append(&pkg_consts, e)
+		case .Variable:   append(&pkg_vars, e)
+		case .Type_Name:  append(&pkg_types, e)
+		case .Procedure:  append(&pkg_procs, e)
+		case .Proc_Group: append(&pkg_proc_groups, e)
+		}
+	}
+
+	entity_key :: proc(e: ^doc.Entity) -> string {
+		return str(e.name)
+	}
+
+	slice.sort_by_key(pkg_procs[:],       entity_key)
+	slice.sort_by_key(pkg_proc_groups[:], entity_key)
+	slice.sort_by_key(pkg_types[:],       entity_key)
+	slice.sort_by_key(pkg_vars[:],        entity_key)
+	slice.sort_by_key(pkg_consts[:],      entity_key)
+
+	print_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
+		fmt.wprintf(w, "<h4>%s</h4>\n", name)
+		fmt.wprintln(w, `<section class="documentation-index">`)
+		fmt.wprintln(w, "<ul>")
+		for e in entities {
+			name := str(e.name)
+			fmt.wprintf(w, "<li><a href=\"#{0:s}\">{0:s}</a></li>\n", name)
+		}
+		fmt.wprintln(w, "</ul>")
+		fmt.wprintln(w, "</section>")
+	}
+
+
+	print_index(w, "Procedures",       pkg_procs[:])
+	print_index(w, "Procedure Groups", pkg_proc_groups[:])
+	print_index(w, "Types",            pkg_types[:])
+	print_index(w, "Variables",        pkg_vars[:])
+	print_index(w, "Constants",        pkg_consts[:])
+
+	fmt.wprintln(w, "</section>")
+
+
+	print_entity :: proc(w: io.Writer, e: ^doc.Entity) {
+		pkg := &pkgs[files[e.pos.file].pkg]
+		name := str(e.name)
+		fmt.wprintf(w, "<h4 id=\"{0:s}\"><a href=\"#{0:s}\">{0:s}</a></h3>\n", name)
+		switch e.kind {
+		case .Invalid, .Import_Name, .Library_Name:
+			// ignore
+		case .Constant:
+		case .Variable:
+		case .Type_Name:
+		case .Procedure:
+			fmt.wprint(w, "<pre>")
+			fmt.wprintf(w, "%s :: ", name)
+			write_type(w, files[e.pos.file].pkg, types[e.type], nil)
+			where_clauses := array(e.where_clauses)
+			if len(where_clauses) != 0 {
+				io.write_string(w, " where ")
+				for clause, i in where_clauses {
+					if i > 0 {
+						io.write_string(w, ", ")
+					}
+					io.write_string(w, str(clause))
+				}
+			}
+
+			fmt.wprint(w, " {…}")
+			fmt.wprintln(w, "</pre>")
+		case .Proc_Group:
+		}
+
+		write_docs(w, pkg, strings.trim_space(str(e.docs)))
+	}
+	print_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
+		fmt.wprintf(w, "<h3>%s</h3>\n", title)
+		fmt.wprintln(w, `<section class="documentation">`)
+		for e in entities {
+			print_entity(w, e)
+		}
+		fmt.wprintln(w, "</section>")
+	}
+
+	print_entities(w, "Procedures",       pkg_procs[:])
+	print_entities(w, "Procedure Groups", pkg_proc_groups[:])
+	print_entities(w, "Types",            pkg_types[:])
+	print_entities(w, "Variables",        pkg_vars[:])
+	print_entities(w, "Constants",        pkg_consts[:])
+
+
+	fmt.wprintln(w, "<h3>Source Files</h3>")
+	fmt.wprintln(w, "<ul>")
+	for file_index in array(pkg.files) {
+		file := files[file_index]
+		filename := slashpath.base(str(file.name))
+		fmt.wprintf(w, `<li><a href="https://github.com/odin-lang/Odin/tree/master/core/%s/%s">%s</a></li>`, path, filename, filename)
+		fmt.wprintln(w)
+	}
+	fmt.wprintln(w, "</ul>")
+
+}
\ No newline at end of file
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
new file mode 100644
index 000000000..7c23d0bc7
--- /dev/null
+++ b/tools/odin-html-docs/style.css
@@ -0,0 +1,31 @@
+.container {
+	max-width: 60em;
+	margin: 0 auto;
+	padding-left: 0.01em 1em;
+}
+
+.directory-pkg {
+	width: 20em;
+}
+
+.directory-child .pkg-name {
+	position: relative;
+	left: 2em;
+	width: 18em;
+}
+
+pre {
+	white-space: pre;
+	tab-size: 8;
+	background-color: #f8f8f8;
+	color: #202224;
+	border: 1px solid #c6c8ca;
+	border-radius: 0.25rem;
+	padding: 0.625rem;
+}
+
+.documentation pre a {
+	text-decoration: none;
+	font-weight: bold;
+	color: #00bfd5;
+}
\ No newline at end of file

From 97922406fec4296ce0732d1eefa0b9d7c943086f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 18:23:30 +0000
Subject: [PATCH 04/37] Improve printing for record types

---
 tools/odin-html-docs/odin_html_docs_main.odin | 253 ++++++++++++++----
 1 file changed, 200 insertions(+), 53 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 7c822e4a1..3cbc0d860 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -32,6 +32,17 @@ errorf :: proc(format: string, args: ..any) -> ! {
 	os.exit(1)
 }
 
+base_type :: proc(t: doc.Type) -> doc.Type {
+	t := t
+	for {
+		if t.kind != .Named {
+			break
+		}
+		t = types[array(t.types)[0]]
+	}
+	return t
+}
+
 common_prefix :: proc(strs: []string) -> string {
 	if len(strs) == 0 {
 		return ""
@@ -270,10 +281,74 @@ is_entity_blank :: proc(e: doc.Entity_Index) -> bool {
 Write_Type_Flag :: enum {
 	Is_Results,
 	Variadic,
+	Allow_Indent,
 }
 Write_Type_Flags :: distinct bit_set[Write_Type_Flag]
+Type_Writer :: struct {
+	w:      io.Writer,
+	pkg:    doc.Pkg_Index,
+	indent: int,
+}
+
+write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type_Flags) {
+	write_param_entity :: proc(using writer: ^Type_Writer, e: ^doc.Entity, flags: Write_Type_Flags, name_width := 0) {
+		name := str(e.name)
+
+		if .Param_Using     in e.flags { io.write_string(w, "using ")      }
+		if .Param_Const     in e.flags { io.write_string(w, "#const ")     }
+		if .Param_Auto_Cast in e.flags { io.write_string(w, "#auto_cast ") }
+		if .Param_CVararg   in e.flags { io.write_string(w, "#c_vararg ")  }
+		if .Param_No_Alias  in e.flags { io.write_string(w, "#no_alias ")  }
+		if .Param_Any_Int   in e.flags { io.write_string(w, "#any_int ")   }
+
+		if name != "" {
+			io.write_string(w, name)
+			io.write_string(w, ": ")
+		}
+		padding := max(name_width-len(name), 0)
+		for _ in 0..<padding {
+			io.write_byte(w, ' ')
+		}
+
+		param_flags := flags - {.Is_Results}
+		if .Param_Ellipsis in e.flags {
+			param_flags += {.Variadic}
+		}
+		write_type(writer, types[e.type], param_flags)
+	}
+	write_poly_params :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type_Flags) {
+		type_entites := array(type.entities)
+		for entity_index, i in type_entites {
+			if i > 0 {
+				io.write_string(w, ", ")
+			}
+			write_param_entity(writer, &entities[entity_index], flags)
+		}
+		io.write_byte(w, ')')
+	}
+	do_indent :: proc(using writer: ^Type_Writer, flags: Write_Type_Flags) {
+		if .Allow_Indent not_in flags {
+			return
+		}
+		for _ in 0..<indent {
+			io.write_byte(w, '\t')
+		}
+	}
+	do_newline :: proc(using writer: ^Type_Writer, flags: Write_Type_Flags) {
+		if .Allow_Indent in flags {
+			io.write_byte(w, '\n')
+		}
+	}
+	calc_name_width :: proc(type_entites: []doc.Entity_Index) -> (name_width: int) {
+		for entity_index in type_entites {
+			e := &entities[entity_index]
+			name := str(e.name)
+			name_width = max(len(name), name_width)
+		}
+		return
+	}
+
 
-write_type :: proc(w: io.Writer, pkg: doc.Pkg_Index, type: doc.Type, flags: Write_Type_Flags) {
 	type_entites := array(type.entities)
 	type_types := array(type.types)
 	switch type.kind {
@@ -301,75 +376,128 @@ write_type :: proc(w: io.Writer, pkg: doc.Pkg_Index, type: doc.Type, flags: Writ
 		io.write_string(w, name)
 		if len(array(type.types)) == 1 {
 			io.write_byte(w, '/')
-			write_type(w, pkg, types[type_types[0]], flags)
+			write_type(writer, types[type_types[0]], flags)
 		}
 	case .Pointer:
 		io.write_byte(w, '^')
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	case .Array:
 		assert(type.elem_count_len == 1)
 		io.write_byte(w, '[')
 		io.write_uint(w, uint(type.elem_counts[0]))
 		io.write_byte(w, ']')
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	case .Enumerated_Array:
 		io.write_byte(w, '[')
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 		io.write_byte(w, ']')
-		write_type(w, pkg, types[type_types[1]], flags)
+		write_type(writer, types[type_types[1]], flags)
 	case .Slice:
 		if .Variadic in flags {
 			io.write_string(w, "..")
 		} else {
 			io.write_string(w, "[]")
 		}
-		write_type(w, pkg, types[type_types[0]], flags - {.Variadic})
+		write_type(writer, types[type_types[0]], flags - {.Variadic})
 	case .Dynamic_Array:
 		io.write_string(w, "[dynamic]")
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	case .Map:
 		io.write_string(w, "map[")
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 		io.write_byte(w, ']')
-		write_type(w, pkg, types[type_types[1]], flags)
+		write_type(writer, types[type_types[1]], flags)
 	case .Struct:
 		type_flags := transmute(doc.Type_Flags_Struct)type.flags
-		io.write_string(w, "struct {}")
+		io.write_string(w, "struct")
+		if .Polymorphic in type_flags {
+			write_poly_params(writer, type, flags)
+		}
+		if .Packed in type_flags { io.write_string(w, " #packed") }
+		if .Raw_Union in type_flags { io.write_string(w, " #raw_union") }
+		if custom_align := str(type.custom_align); custom_align != "" {
+			io.write_string(w, " #align")
+			io.write_string(w, custom_align)
+		}
+		io.write_string(w, " {")
+		do_newline(writer, flags)
+		indent += 1
+		name_width := calc_name_width(type_entites)
+
+		for entity_index in type_entites {
+			e := &entities[entity_index]
+			do_indent(writer, flags)
+			write_param_entity(writer, e, flags, name_width)
+			io.write_byte(w, ',')
+			do_newline(writer, flags)
+		}
+		indent -= 1
+		do_indent(writer, flags)
+		io.write_string(w, "}")
 	case .Union:
 		type_flags := transmute(doc.Type_Flags_Union)type.flags
-		io.write_string(w, "union {}")
+		io.write_string(w, "union")
+		if .Polymorphic in type_flags {
+			write_poly_params(writer, type, flags)
+		}
+		if .No_Nil in type_flags { io.write_string(w, " #no_nil") }
+		if .Maybe in type_flags { io.write_string(w, " #maybe") }
+		if custom_align := str(type.custom_align); custom_align != "" {
+			io.write_string(w, " #align")
+			io.write_string(w, custom_align)
+		}
+		io.write_string(w, " {")
+		if len(type_types) > 1 {
+			do_newline(writer, flags)
+			indent += 1
+			for type_index in type_types {
+				do_indent(writer, flags)
+				write_type(writer, types[type_index], flags)
+				io.write_string(w, ", ")
+				do_newline(writer, flags)
+			}
+			indent -= 1
+			do_indent(writer, flags)
+		}
+		io.write_string(w, "}")
 	case .Enum:
-		io.write_string(w, "enum {}")
+		io.write_string(w, "enum")
+		io.write_string(w, " {")
+		do_newline(writer, flags)
+		indent += 1
+
+		name_width := calc_name_width(type_entites)
+
+		for entity_index in type_entites {
+			e := &entities[entity_index]
+
+			do_indent(writer, flags)
+			io.write_string(w, str(e.name))
+
+			if init_string := str(e.init_string); init_string != "" {
+				for _ in 0..<name_width {
+					io.write_byte(w, ' ')
+				}
+				io.write_string(w, " = ")
+				io.write_string(w, init_string)
+			}
+			io.write_string(w, ", ")
+			do_newline(writer, flags)
+		}
+		indent -= 1
+		do_indent(writer, flags)
+		io.write_string(w, "}")
 	case .Tuple:
-		entity_indices := type_entites
-		if len(entity_indices) == 0 {
+		if len(type_entites) == 0 {
 			return
 		}
-		require_parens := (.Is_Results in flags) && (len(entity_indices) > 1 || !is_entity_blank(entity_indices[0]))
+		require_parens := (.Is_Results in flags) && (len(type_entites) > 1 || !is_entity_blank(type_entites[0]))
 		if require_parens { io.write_byte(w, '(') }
-		for entity_index, i in entity_indices {
-			e := &entities[entity_index]
-			name := str(e.name)
-
+		for entity_index, i in type_entites {
 			if i > 0 {
 				io.write_string(w, ", ")
 			}
-			if .Param_Using     in e.flags { io.write_string(w, "using ")      }
-			if .Param_Const     in e.flags { io.write_string(w, "#const ")     }
-			if .Param_Auto_Cast in e.flags { io.write_string(w, "#auto_cast ") }
-			if .Param_CVararg   in e.flags { io.write_string(w, "#c_vararg ")  }
-			if .Param_No_Alias  in e.flags { io.write_string(w, "#no_alias ")  }
-			if .Param_Any_Int   in e.flags { io.write_string(w, "#any_int ")   }
-
-			if name != "" {
-				io.write_string(w, name)
-				io.write_string(w, ": ")
-			}
-			param_flags := flags - {.Is_Results}
-			if .Param_Ellipsis in e.flags {
-				param_flags += {.Variadic}
-			}
-			write_type(w, pkg, types[e.type], param_flags)
+			write_param_entity(writer, &entities[entity_index], flags)
 		}
 		if require_parens { io.write_byte(w, ')') }
 
@@ -385,12 +513,12 @@ write_type :: proc(w: io.Writer, pkg: doc.Pkg_Index, type: doc.Type, flags: Writ
 		params := array(type.types)[0]
 		results := array(type.types)[1]
 		io.write_byte(w, '(')
-		write_type(w, pkg, types[params], flags)
+		write_type(writer, types[params], flags)
 		io.write_byte(w, ')')
 		if results != 0 {
 			assert(.Diverging not_in type_flags)
 			io.write_string(w, " -> ")
-			write_type(w, pkg, types[results], flags+{.Is_Results})
+			write_type(writer, types[results], flags+{.Is_Results})
 		}
 		if .Diverging in type_flags {
 			io.write_string(w, " -> !")
@@ -415,24 +543,24 @@ write_type :: proc(w: io.Writer, pkg: doc.Pkg_Index, type: doc.Type, flags: Writ
 		io.write_string(w, "#soa[dynamic]")
 	case .Relative_Pointer:
 		io.write_string(w, "#relative(")
-		write_type(w, pkg, types[type_types[1]], flags)
+		write_type(writer, types[type_types[1]], flags)
 		io.write_string(w, ") ")
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	case .Relative_Slice:
 		io.write_string(w, "#relative(")
-		write_type(w, pkg, types[type_types[1]], flags)
+		write_type(writer, types[type_types[1]], flags)
 		io.write_string(w, ") ")
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	case .Multi_Pointer:
 		io.write_string(w, "[^]")
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	case .Matrix:
 		io.write_string(w, "matrix[")
 		io.write_uint(w, uint(type.elem_counts[0]))
 		io.write_string(w, ", ")
 		io.write_uint(w, uint(type.elem_counts[1]))
 		io.write_string(w, "]")
-		write_type(w, pkg, types[type_types[0]], flags)
+		write_type(writer, types[type_types[0]], flags)
 	}
 }
 
@@ -529,12 +657,16 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	print_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
 		fmt.wprintf(w, "<h4>%s</h4>\n", name)
 		fmt.wprintln(w, `<section class="documentation-index">`)
-		fmt.wprintln(w, "<ul>")
-		for e in entities {
-			name := str(e.name)
-			fmt.wprintf(w, "<li><a href=\"#{0:s}\">{0:s}</a></li>\n", name)
+		if len(entities) == 0 {
+			io.write_string(w, "<p>This section is empty.</p>\n")
+		} else {
+			fmt.wprintln(w, "<ul>")
+			for e in entities {
+				name := str(e.name)
+				fmt.wprintf(w, "<li><a href=\"#{0:s}\">{0:s}</a></li>\n", name)
+			}
+			fmt.wprintln(w, "</ul>")
 		}
-		fmt.wprintln(w, "</ul>")
 		fmt.wprintln(w, "</section>")
 	}
 
@@ -549,7 +681,13 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 
 
 	print_entity :: proc(w: io.Writer, e: ^doc.Entity) {
-		pkg := &pkgs[files[e.pos.file].pkg]
+		pkg_index := files[e.pos.file].pkg
+		pkg := &pkgs[pkg_index]
+		writer := &Type_Writer{
+			w = w,
+			pkg = pkg_index,
+		}
+
 		name := str(e.name)
 		fmt.wprintf(w, "<h4 id=\"{0:s}\"><a href=\"#{0:s}\">{0:s}</a></h3>\n", name)
 		switch e.kind {
@@ -558,10 +696,15 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		case .Constant:
 		case .Variable:
 		case .Type_Name:
+			fmt.wprint(w, "<pre>")
+			fmt.wprintf(w, "%s :: ", name)
+			tn := base_type(types[e.type])
+			write_type(writer, tn, {.Allow_Indent})
+			fmt.wprintln(w, "</pre>")
 		case .Procedure:
 			fmt.wprint(w, "<pre>")
 			fmt.wprintf(w, "%s :: ", name)
-			write_type(w, files[e.pos.file].pkg, types[e.type], nil)
+			write_type(writer, types[e.type], nil)
 			where_clauses := array(e.where_clauses)
 			if len(where_clauses) != 0 {
 				io.write_string(w, " where ")
@@ -583,8 +726,12 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	print_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
 		fmt.wprintf(w, "<h3>%s</h3>\n", title)
 		fmt.wprintln(w, `<section class="documentation">`)
-		for e in entities {
-			print_entity(w, e)
+		if len(entities) == 0 {
+			io.write_string(w, "<p>This section is empty.</p>\n")
+		} else {
+			for e in entities {
+				print_entity(w, e)
+			}
 		}
 		fmt.wprintln(w, "</section>")
 	}

From c85ac955f798fefd149a5eeaecabf0713210b152 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 19:00:47 +0000
Subject: [PATCH 05/37] Simplify docs to hide the copyright

---
 core/compress/common.odin   |  3 +++
 core/encoding/hxa/doc.odin  | 12 ++++++------
 core/fmt/doc.odin           |  2 +-
 core/image/common.odin      |  2 ++
 core/image/png/png.odin     |  5 +++++
 core/math/big/api.odin      |  6 ++----
 core/math/big/common.odin   |  6 ++----
 core/math/big/doc.odin      | 28 ++++++++++++++++++++++++++++
 core/math/big/helpers.odin  |  6 ++----
 core/math/big/internal.odin | 28 ++--------------------------
 core/math/big/logical.odin  |  2 ++
 core/math/big/prime.odin    |  2 ++
 core/math/big/private.odin  |  2 ++
 core/math/big/public.odin   |  2 ++
 core/math/big/radix.odin    |  2 ++
 core/math/big/tune.odin     |  2 ++
 16 files changed, 65 insertions(+), 45 deletions(-)
 create mode 100644 core/math/big/doc.odin

diff --git a/core/compress/common.odin b/core/compress/common.odin
index 41f292b6f..5f5ef2413 100644
--- a/core/compress/common.odin
+++ b/core/compress/common.odin
@@ -5,6 +5,9 @@
 	List of contributors:
 		Jeroen van Rijn: Initial implementation, optimization.
 */
+
+
+// package compress is a collection of utilities to aid with other compression packages
 package compress
 
 import "core:io"
diff --git a/core/encoding/hxa/doc.odin b/core/encoding/hxa/doc.odin
index 16b94a243..230d6ea66 100644
--- a/core/encoding/hxa/doc.odin
+++ b/core/encoding/hxa/doc.odin
@@ -27,7 +27,7 @@
 // 	Construction history, or BSP trees would make the format too large to serve its purpose.
 // 	The facilities of the formats to store meta data should make the format flexible enough
 // 	for most uses. Adding HxA support should be something anyone can do in a days work.
-
+//
 // Structure:
 // ----------
 // HxA is designed to be extremely simple to parse, and is therefore based around conventions. It has
@@ -45,17 +45,17 @@
 // of a number of named layers. All layers in the stack have the same number of elements. Each layer
 // describes one property of the primitive. Each layer can have multiple channels and each layer can
 // store data of a different type.
-
+//
 // HaX stores 3 kinds of nodes
 // 	- Pixel data.
 // 	- Polygon geometry data.
 // 	- Meta data only.
-
+//
 // Pixel Nodes stores pixels in a layer stack. A layer may store things like Albedo, Roughness,
 // Reflectance, Light maps, Masks, Normal maps, and Displacement. Layers use the channels of the
 // layers to store things like color. The length of the layer stack is determined by the type and
 // dimensions stored in the
-
+//
 // Geometry data is stored in 3 separate layer stacks for: vertex data, corner data and face data. The
 // vertex data stores things like verities, blend shapes, weight maps, and vertex colors. The first
 // layer in a vertex stack has to be a 3 channel layer named "position" describing the base position
@@ -63,7 +63,7 @@
 // for things like UV, normals, and adjacency. The first layer in a corner stack has to be a 1 channel
 // integer layer named "index" describing the vertices used to form polygons. The last value in each
 // polygon has a negative - 1 index to indicate the end of the polygon.
-
+//
 // Example:
 // 	A quad and a tri with the vertex index:
 // 		[0, 1, 2, 3] [1, 4, 2]
@@ -72,7 +72,7 @@
 // The face stack stores values per face. the length of the face stack has to match the number of
 // negative values in the index layer in the corner stack. The face stack can be used to store things
 // like material index.
-
+//
 // Storage
 // -------
 // All data is stored in little endian byte order with no padding. The layout mirrors the structs
diff --git a/core/fmt/doc.odin b/core/fmt/doc.odin
index 5984da950..668fc9bc6 100644
--- a/core/fmt/doc.odin
+++ b/core/fmt/doc.odin
@@ -64,6 +64,7 @@ If not present, the width is whatever is necessary to represent the value.
 Precision is specified after the (optional) width followed by a period followed by a decimal number.
 If no period is present, a default precision is used.
 A period with no following number specifies a precision of 0.
+
 Examples:
 	%f     default width, default precision
 	%8f    width 8, default precision
@@ -84,7 +85,6 @@ Other flags:
 	               add leading 0z for dozenal (%#z)
 	               add leading 0x or 0X for hexadecimal (%#x or %#X)
 	               remove leading 0x for %p (%#p)
-
 	' '    (space) leave a space for elided sign in numbers (% d)
 	0      pad with leading zeros rather than spaces
 
diff --git a/core/image/common.odin b/core/image/common.odin
index 3ec8e15be..d72b770d5 100644
--- a/core/image/common.odin
+++ b/core/image/common.odin
@@ -6,6 +6,8 @@
 		Jeroen van Rijn: Initial implementation, optimization.
 		Ginger Bill:     Cosmetic changes.
 */
+
+// package image implements a general 2D image library to be used with other image related packages
 package image
 
 import "core:bytes"
diff --git a/core/image/png/png.odin b/core/image/png/png.odin
index da76a4588..bff0afde3 100644
--- a/core/image/png/png.odin
+++ b/core/image/png/png.odin
@@ -6,6 +6,11 @@
 		Jeroen van Rijn: Initial implementation.
 		Ginger Bill:     Cosmetic changes.
 */
+
+
+// package png implements a PNG image reader
+//
+// The PNG specification is at https://www.w3.org/TR/PNG/.
 package png
 
 import "core:compress"
diff --git a/core/math/big/api.odin b/core/math/big/api.odin
index c9be04da0..bf19e83b6 100644
--- a/core/math/big/api.odin
+++ b/core/math/big/api.odin
@@ -2,12 +2,10 @@
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
 
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
 	This file collects public proc maps and their aliases.
 */
+
+
 package math_big
 /*
 
diff --git a/core/math/big/common.odin b/core/math/big/common.odin
index 31ad54b14..2b34a9163 100644
--- a/core/math/big/common.odin
+++ b/core/math/big/common.odin
@@ -1,11 +1,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:intrinsics"
diff --git a/core/math/big/doc.odin b/core/math/big/doc.odin
new file mode 100644
index 000000000..f5e0900f5
--- /dev/null
+++ b/core/math/big/doc.odin
@@ -0,0 +1,28 @@
+/*
+A BigInt implementation in Odin.
+For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
+The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
+
+==========================    Low-level routines    ==========================
+
+IMPORTANT: `internal_*` procedures make certain assumptions about their input.
+
+The public functions that call them are expected to satisfy their sanity check requirements.
+This allows `internal_*` call `internal_*` without paying this overhead multiple times.
+
+Where errors can occur, they are of course still checked and returned as appropriate.
+
+When importing `math:core/big` to implement an involved algorithm of your own, you are welcome
+to use these procedures instead of their public counterparts.
+
+Most inputs and outputs are expected to be passed an initialized `Int`, for example.
+Exceptions include `quotient` and `remainder`, which are allowed to be `nil` when the calling code doesn't need them.
+
+Check the comments above each `internal_*` implementation to see what constraints it expects to have met.
+
+We pass the custom allocator to procedures by default using the pattern `context.allocator = allocator`.
+This way we don't have to add `, allocator` at the end of each call.
+
+TODO: Handle +/- Infinity and NaN.
+*/
+package math_big
diff --git a/core/math/big/helpers.odin b/core/math/big/helpers.odin
index 6d13d32bb..6c4b5dd01 100644
--- a/core/math/big/helpers.odin
+++ b/core/math/big/helpers.odin
@@ -1,11 +1,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:intrinsics"
diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin
index 437f6e5fc..5085898e5 100644
--- a/core/math/big/internal.odin
+++ b/core/math/big/internal.odin
@@ -2,33 +2,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	A BigInt implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
-	==========================    Low-level routines    ==========================
-
-	IMPORTANT: `internal_*` procedures make certain assumptions about their input.
-
-	The public functions that call them are expected to satisfy their sanity check requirements.
-	This allows `internal_*` call `internal_*` without paying this overhead multiple times.
-
-	Where errors can occur, they are of course still checked and returned as appropriate.
-
-	When importing `math:core/big` to implement an involved algorithm of your own, you are welcome
-	to use these procedures instead of their public counterparts.
-
-	Most inputs and outputs are expected to be passed an initialized `Int`, for example.
-	Exceptions include `quotient` and `remainder`, which are allowed to be `nil` when the calling code doesn't need them.
-
-	Check the comments above each `internal_*` implementation to see what constraints it expects to have met.
-
-	We pass the custom allocator to procedures by default using the pattern `context.allocator = allocator`.
-	This way we don't have to add `, allocator` at the end of each call.
-
-	TODO: Handle +/- Infinity and NaN.
 */
+
+
 package math_big
 
 import "core:mem"
diff --git a/core/math/big/logical.odin b/core/math/big/logical.odin
index e7e55cc47..b5de4cabf 100644
--- a/core/math/big/logical.odin
+++ b/core/math/big/logical.odin
@@ -8,6 +8,8 @@
 
 	This file contains logical operations like `and`, `or` and `xor`.
 */
+
+
 package math_big
 
 /*
diff --git a/core/math/big/prime.odin b/core/math/big/prime.odin
index eb0cd644c..3cce69675 100644
--- a/core/math/big/prime.odin
+++ b/core/math/big/prime.odin
@@ -8,6 +8,8 @@
 
 	This file contains prime finding operations.
 */
+
+
 package math_big
 
 import rnd "core:math/rand"
diff --git a/core/math/big/private.odin b/core/math/big/private.odin
index 9989a208a..419f2103f 100644
--- a/core/math/big/private.odin
+++ b/core/math/big/private.odin
@@ -15,6 +15,8 @@
 
 	These aren't exported for the same reasons.
 */
+
+
 package math_big
 
 import "core:intrinsics"
diff --git a/core/math/big/public.odin b/core/math/big/public.odin
index 2673a262f..3227d7bc4 100644
--- a/core/math/big/public.odin
+++ b/core/math/big/public.odin
@@ -8,6 +8,8 @@
 
 	This file contains basic arithmetic operations like `add`, `sub`, `mul`, `div`, ...
 */
+
+
 package math_big
 
 import "core:intrinsics"
diff --git a/core/math/big/radix.odin b/core/math/big/radix.odin
index 760c49d77..2b758dc35 100644
--- a/core/math/big/radix.odin
+++ b/core/math/big/radix.odin
@@ -12,6 +12,8 @@
 		- Use Barrett reduction for non-powers-of-two.
 		- Also look at extracting and splatting several digits at once.
 */
+
+
 package math_big
 
 import "core:intrinsics"
diff --git a/core/math/big/tune.odin b/core/math/big/tune.odin
index d67ff61b4..64a73b656 100644
--- a/core/math/big/tune.odin
+++ b/core/math/big/tune.odin
@@ -7,6 +7,8 @@
 	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
 	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:time"

From 8eda7567141316627973d0018bfb7e80ebdf90aa Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 19:01:16 +0000
Subject: [PATCH 06/37] Add printing for constants, variables, types, and
 procedure groups

---
 tools/odin-html-docs/odin_html_docs_main.odin | 97 +++++++++++++++----
 tools/odin-html-docs/style.css                |  6 +-
 2 files changed, 83 insertions(+), 20 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 3cbc0d860..d1e4f4432 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -114,27 +114,30 @@ main :: proc() {
 	entities = array(header.entities)
 	types    = array(header.types)
 
-	fullpaths: [dynamic]string
-	defer delete(fullpaths)
+	{
+		fullpaths: [dynamic]string
+		defer delete(fullpaths)
 
-	for pkg in pkgs[1:] {
-		append(&fullpaths, str(pkg.fullpath))
-	}
-	path_prefix := common_prefix(fullpaths[:])
-
-	pkgs_to_use = make(map[string]^doc.Pkg)
-	for fullpath, i in fullpaths {
-		path := strings.trim_prefix(fullpath, path_prefix)
-		if strings.has_prefix(path, "core/") {
-			pkgs_to_use[strings.trim_prefix(path, "core/")] = &pkgs[i+1]
+		for pkg in pkgs[1:] {
+			append(&fullpaths, str(pkg.fullpath))
+		}
+		path_prefix := common_prefix(fullpaths[:])
+
+		pkgs_to_use = make(map[string]^doc.Pkg)
+		for fullpath, i in fullpaths {
+			path := strings.trim_prefix(fullpath, path_prefix)
+			if strings.has_prefix(path, "core/") {
+				pkgs_to_use[strings.trim_prefix(path, "core/")] = &pkgs[i+1]
+			}
+		}
+		sort.map_entries_by_key(&pkgs_to_use)
+		for path, pkg in pkgs_to_use {
+			pkg_to_path[pkg] = path
 		}
-	}
-	sort.map_entries_by_key(&pkgs_to_use)
-	for path, pkg in pkgs_to_use {
-		pkg_to_path[pkg] = path
 	}
 
 	b := strings.make_builder()
+	defer strings.destroy_builder(&b)
 	w := strings.to_writer(&b)
 	{
 		strings.reset_builder(&b)
@@ -369,7 +372,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		if tn_pkg != pkg {
 			fmt.wprintf(w, `%s.`, str(pkgs[pkg].name))
 		}
-		fmt.wprintf(w, `<a href="/core/{0:s}/#{1:s}">{1:s}</a></span>`, pkg_to_path[&pkgs[tn_pkg]], name)
+		fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a></span>`, pkg_to_path[&pkgs[tn_pkg]], name)
 	case .Generic:
 		name := str(type.name)
 		io.write_byte(w, '$')
@@ -694,12 +697,49 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		case .Invalid, .Import_Name, .Library_Name:
 			// ignore
 		case .Constant:
+			fmt.wprint(w, "<pre>")
+			the_type := types[e.type]
+			if the_type.kind == .Basic && .Untyped in (transmute(doc.Type_Flags_Basic)the_type.flags) {
+				fmt.wprintf(w, "%s :: ", name)
+			} else {
+				fmt.wprintf(w, "%s: ", name)
+				write_type(writer, the_type, {.Allow_Indent})
+				fmt.wprintf(w, " : ")
+			}
+
+			init_string := str(e.init_string)
+			assert(init_string != "")
+			io.write_string(w, init_string)
+			fmt.wprintln(w, "</pre>")
 		case .Variable:
+			fmt.wprint(w, "<pre>")
+			fmt.wprintf(w, "%s: ", name)
+			write_type(writer, types[e.type], {.Allow_Indent})
+			init_string := str(e.init_string)
+			if init_string != "" {
+				io.write_string(w, " = ")
+				io.write_string(w, init_string)
+			}
+			fmt.wprintln(w, "</pre>")
+
 		case .Type_Name:
 			fmt.wprint(w, "<pre>")
 			fmt.wprintf(w, "%s :: ", name)
-			tn := base_type(types[e.type])
-			write_type(writer, tn, {.Allow_Indent})
+			the_type := types[e.type]
+			type_to_print := the_type
+			if the_type.kind == .Named {
+				if e.pos != entities[array(the_type.entities)[0]].pos {
+					io.write_string(w, "distinct ")
+				} else {
+					bt := base_type(the_type)
+					#partial switch bt.kind {
+					case .Struct, .Union, .Proc, .Enum:
+						io.write_string(w, "distinct ")
+						type_to_print = bt
+					}
+				}
+			}
+			write_type(writer, type_to_print, {.Allow_Indent})
 			fmt.wprintln(w, "</pre>")
 		case .Procedure:
 			fmt.wprint(w, "<pre>")
@@ -719,6 +759,25 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprint(w, " {…}")
 			fmt.wprintln(w, "</pre>")
 		case .Proc_Group:
+			fmt.wprint(w, "<pre>")
+			fmt.wprintf(w, "%s :: proc{{\n", name)
+			for entity_index in array(e.grouped_entities) {
+				this_proc := &entities[entity_index]
+				this_pkg := files[this_proc.pos.file].pkg
+				io.write_byte(w, '\t')
+				if this_pkg != pkg_index {
+					fmt.wprintf(w, "%s.", str(pkgs[this_pkg].name))
+				}
+				name := str(this_proc.name)
+				fmt.wprintf(w, `<a class="code-procedure" href="/core/{0:s}/#{1:s}">`, pkg_to_path[&pkgs[this_pkg]], name)
+				io.write_string(w, name)
+				io.write_string(w, `</a>`)
+				io.write_byte(w, ',')
+				io.write_byte(w, '\n')
+			}
+			fmt.wprintln(w, "}")
+			fmt.wprintln(w, "</pre>")
+
 		}
 
 		write_docs(w, pkg, strings.trim_space(str(e.docs)))
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index 7c23d0bc7..1f334ad91 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -28,4 +28,8 @@ pre {
 	text-decoration: none;
 	font-weight: bold;
 	color: #00bfd5;
-}
\ No newline at end of file
+}
+
+pre a.code-procedure {
+	color: #079300;
+}

From 0d4642825fc0d9ad5009bb4e4cae467ee9900112 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 19:07:25 +0000
Subject: [PATCH 07/37] Correct package docs parsing

---
 src/parser.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/parser.cpp b/src/parser.cpp
index 5bf43cee9..7e7146244 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -5412,6 +5412,15 @@ bool parse_file(Parser *p, AstFile *f) {
 	if (f->package_token.kind != Token_package) {
 		return false;
 	}
+	if (docs != nullptr) {
+		TokenPos end = token_pos_end(docs->list[docs->list.count-1]);
+		if (end.line == f->package_token.pos.line || end.line+1 == f->package_token.pos.line) {
+			// Okay
+		} else {
+			docs = nullptr;
+		}
+	}
+
 	Token package_name = expect_token_after(f, Token_Ident, "package");
 	if (package_name.kind == Token_Ident) {
 		if (package_name.string == "_") {

From 2ca2dbcc923a005b95459b1ad4c6f5b5600fd17c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 19:23:24 +0000
Subject: [PATCH 08/37] Correct `distinct` printing

---
 tools/odin-html-docs/odin_html_docs_main.odin | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index d1e4f4432..90010369d 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -370,7 +370,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		fmt.wprintf(w, `<span>`)
 		tn_pkg := files[e.pos.file].pkg
 		if tn_pkg != pkg {
-			fmt.wprintf(w, `%s.`, str(pkgs[pkg].name))
+			fmt.wprintf(w, `%s.`, str(pkgs[tn_pkg].name))
 		}
 		fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a></span>`, pkg_to_path[&pkgs[tn_pkg]], name)
 	case .Generic:
@@ -727,16 +727,16 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintf(w, "%s :: ", name)
 			the_type := types[e.type]
 			type_to_print := the_type
-			if the_type.kind == .Named {
-				if e.pos != entities[array(the_type.entities)[0]].pos {
-					io.write_string(w, "distinct ")
-				} else {
+			if the_type.kind == .Named && .Type_Alias not_in e.flags {
+				if e.pos == entities[array(the_type.entities)[0]].pos {
 					bt := base_type(the_type)
 					#partial switch bt.kind {
 					case .Struct, .Union, .Proc, .Enum:
+						// Okay
+					case:
 						io.write_string(w, "distinct ")
-						type_to_print = bt
 					}
+					type_to_print = bt
 				}
 			}
 			write_type(writer, type_to_print, {.Allow_Indent})

From e9ae6e20e859eb68b01f3e55ca955a2e08cf446b Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 20:50:40 +0000
Subject: [PATCH 09/37] Fix code, source code links, and add recursive make
 directory

---
 tools/odin-html-docs/odin_html_docs_main.odin | 179 ++++++++++++++----
 tools/odin-html-docs/style.css                |  32 +++-
 2 files changed, 174 insertions(+), 37 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 90010369d..4260bd697 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -9,6 +9,8 @@ import "core:path/slashpath"
 import "core:sort"
 import "core:slice"
 
+GITHUB_CORE_URL :: "https://github.com/odin-lang/Odin/tree/master/core"
+
 header:   ^doc.Header
 files:    []doc.File
 pkgs:     []doc.Pkg
@@ -64,6 +66,18 @@ common_prefix :: proc(strs: []string) -> string {
 	return prefix
 }
 
+recursive_make_directory :: proc(path: string, prefix := "") {
+	head, _, tail := strings.partition(path, "/")
+	path_to_make := head
+	if prefix != "" {
+		path_to_make = fmt.tprintf("%s/%s", prefix, head)
+	}
+	os.make_directory(path_to_make, 0)
+	if tail != "" {
+		recursive_make_directory(tail, path_to_make)
+	}
+}
+
 
 write_html_header :: proc(w: io.Writer, title: string) {
 	fmt.wprintf(w, `<!DOCTYPE html>
@@ -124,11 +138,21 @@ main :: proc() {
 		path_prefix := common_prefix(fullpaths[:])
 
 		pkgs_to_use = make(map[string]^doc.Pkg)
-		for fullpath, i in fullpaths {
+		fullpath_loop: for fullpath, i in fullpaths {
 			path := strings.trim_prefix(fullpath, path_prefix)
-			if strings.has_prefix(path, "core/") {
-				pkgs_to_use[strings.trim_prefix(path, "core/")] = &pkgs[i+1]
+			if !strings.has_prefix(path, "core/") {
+				continue fullpath_loop
 			}
+			pkg := &pkgs[i+1]
+			if len(array(pkg.entities)) == 0 {
+				continue fullpath_loop
+			}
+			trimmed_path := strings.trim_prefix(path, "core/")
+			if strings.has_prefix(trimmed_path, "sys") {
+				continue fullpath_loop
+			}
+
+			pkgs_to_use[trimmed_path] = pkg
 		}
 		sort.map_entries_by_key(&pkgs_to_use)
 		for path, pkg in pkgs_to_use {
@@ -153,7 +177,7 @@ main :: proc() {
 		write_html_header(w, fmt.tprintf("package %s - pkg.odin-lang.org", path))
 		write_pkg(w, path, pkg)
 		write_html_footer(w)
-		os.make_directory(fmt.tprintf("core/%s", path), 0)
+		recursive_make_directory(path, "core")
 		os.write_entire_file(fmt.tprintf("core/%s/index.html", path), b.buf[:])
 	}
 }
@@ -304,20 +328,37 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		if .Param_No_Alias  in e.flags { io.write_string(w, "#no_alias ")  }
 		if .Param_Any_Int   in e.flags { io.write_string(w, "#any_int ")   }
 
-		if name != "" {
+		init_string := str(e.init_string)
+		switch init_string {
+		case "#caller_location":
+			assert(name != "")
 			io.write_string(w, name)
-			io.write_string(w, ": ")
-		}
-		padding := max(name_width-len(name), 0)
-		for _ in 0..<padding {
-			io.write_byte(w, ' ')
-		}
+			io.write_string(w, " := ")
+			io.write_string(w, `<a href="/core/runtime/#Source_Code_Location">`)
+			io.write_string(w, init_string)
+			io.write_string(w, `</a>`)
 
-		param_flags := flags - {.Is_Results}
-		if .Param_Ellipsis in e.flags {
-			param_flags += {.Variadic}
+		case:
+			if name != "" {
+				io.write_string(w, name)
+				io.write_string(w, ": ")
+			}
+			padding := max(name_width-len(name), 0)
+			for _ in 0..<padding {
+				io.write_byte(w, ' ')
+			}
+
+			param_flags := flags - {.Is_Results}
+			if .Param_Ellipsis in e.flags {
+				param_flags += {.Variadic}
+			}
+			write_type(writer, types[e.type], param_flags)
+
+			if init_string != "" {
+				io.write_string(w, " = ")
+				io.write_string(w, init_string)
+			}
 		}
-		write_type(writer, types[e.type], param_flags)
 	}
 	write_poly_params :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type_Flags) {
 		type_entites := array(type.entities)
@@ -423,19 +464,21 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			io.write_string(w, custom_align)
 		}
 		io.write_string(w, " {")
-		do_newline(writer, flags)
-		indent += 1
-		name_width := calc_name_width(type_entites)
-
-		for entity_index in type_entites {
-			e := &entities[entity_index]
-			do_indent(writer, flags)
-			write_param_entity(writer, e, flags, name_width)
-			io.write_byte(w, ',')
+		if len(type_entites) != 0 {
 			do_newline(writer, flags)
+			indent += 1
+			name_width := calc_name_width(type_entites)
+
+			for entity_index in type_entites {
+				e := &entities[entity_index]
+				do_indent(writer, flags)
+				write_param_entity(writer, e, flags, name_width)
+				io.write_byte(w, ',')
+				do_newline(writer, flags)
+			}
+			indent -= 1
+			do_indent(writer, flags)
 		}
-		indent -= 1
-		do_indent(writer, flags)
 		io.write_string(w, "}")
 	case .Union:
 		type_flags := transmute(doc.Type_Flags_Union)type.flags
@@ -465,6 +508,10 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		io.write_string(w, "}")
 	case .Enum:
 		io.write_string(w, "enum")
+		if len(type_types) != 0 {
+			io.write_byte(w, ' ')
+			write_type(writer, types[type_types[0]], flags)
+		}
 		io.write_string(w, " {")
 		do_newline(writer, flags)
 		indent += 1
@@ -474,11 +521,12 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		for entity_index in type_entites {
 			e := &entities[entity_index]
 
+			name := str(e.name)
 			do_indent(writer, flags)
-			io.write_string(w, str(e.name))
+			io.write_string(w, name)
 
 			if init_string := str(e.init_string); init_string != "" {
-				for _ in 0..<name_width {
+				for _ in 0..<name_width-len(name) {
 					io.write_byte(w, ' ')
 				}
 				io.write_string(w, " = ")
@@ -532,6 +580,22 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 
 	case .Bit_Set:
 		type_flags := transmute(doc.Type_Flags_Bit_Set)type.flags
+		io.write_string(w, "bit_set[")
+		if .Op_Lt in type_flags {
+			io.write_uint(w, uint(type.elem_counts[0]))
+			io.write_string(w, "..<")
+			io.write_uint(w, uint(type.elem_counts[1]))
+		} else if .Op_Lt_Eq in type_flags {
+			io.write_uint(w, uint(type.elem_counts[0]))
+			io.write_string(w, "..=")
+			io.write_uint(w, uint(type.elem_counts[1]))
+		} else {
+			write_type(writer, types[type_types[0]], flags)
+		}
+		if .Underlying_Type in type_flags {
+			write_type(writer, types[type_types[1]], flags)
+		}
+		io.write_string(w, "]")
 	case .Simd_Vector:
 		io.write_string(w, "#simd[")
 		io.write_uint(w, uint(type.elem_counts[0]))
@@ -585,6 +649,7 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 		} else if was_code {
 			was_code = false
 			fmt.wprintln(w, "</code></pre>")
+			continue
 		}
 		text := strings.trim_space(line)
 		if text == "" {
@@ -604,8 +669,9 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 	if was_code {
 		// assert(!was_paragraph, str(pkg.name))
 		was_code = false
-		fmt.wprintln(w, "</code>")
-	} else if was_paragraph {
+		fmt.wprintln(w, "</code></pre>")
+	}
+	if was_paragraph {
 		fmt.wprintln(w, "</p>")
 	}
 }
@@ -684,6 +750,21 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 
 
 	print_entity :: proc(w: io.Writer, e: ^doc.Entity) {
+		write_attributes :: proc(w: io.Writer, e: ^doc.Entity) {
+			for attr in array(e.attributes) {
+				io.write_string(w, "@(")
+				name := str(attr.name)
+				value := str(attr.value)
+				io.write_string(w, name)
+				if value != "" {
+					io.write_string(w, "=")
+					io.write_string(w, value)
+				}
+				io.write_string(w, ")\n")
+			}
+		}
+
+
 		pkg_index := files[e.pos.file].pkg
 		pkg := &pkgs[pkg_index]
 		writer := &Type_Writer{
@@ -692,7 +773,15 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		}
 
 		name := str(e.name)
-		fmt.wprintf(w, "<h4 id=\"{0:s}\"><a href=\"#{0:s}\">{0:s}</a></h3>\n", name)
+		path := pkg_to_path[pkg]
+		filename := slashpath.base(str(files[e.pos.file].name))
+		fmt.wprintf(w, "<h4 id=\"{0:s}\"><span><a class=\"documentation-id-link\" href=\"#%s\">{0:s}", name)
+		fmt.wprintf(w, "<span class=\"a-hidden\">&nbsp;¶</span></a></span></h4>\n")
+		defer if e.pos.file != 0 && e.pos.line > 0 {
+			src_url := fmt.tprintf("%s/%s/%s#L%d", GITHUB_CORE_URL, path, filename, e.pos.line)
+			fmt.wprintf(w, "<a class=\"documentation-source\" href=\"{0:s}\"><em>Source:&nbsp;{0:s}</em></a>", src_url)
+		}
+
 		switch e.kind {
 		case .Invalid, .Import_Name, .Library_Name:
 			// ignore
@@ -713,6 +802,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintln(w, "</pre>")
 		case .Variable:
 			fmt.wprint(w, "<pre>")
+			write_attributes(w, e)
 			fmt.wprintf(w, "%s: ", name)
 			write_type(writer, types[e.type], {.Allow_Indent})
 			init_string := str(e.init_string)
@@ -804,12 +894,35 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 
 	fmt.wprintln(w, "<h3>Source Files</h3>")
 	fmt.wprintln(w, "<ul>")
-	for file_index in array(pkg.files) {
+	any_hidden := false
+	source_file_loop: for file_index in array(pkg.files) {
 		file := files[file_index]
 		filename := slashpath.base(str(file.name))
-		fmt.wprintf(w, `<li><a href="https://github.com/odin-lang/Odin/tree/master/core/%s/%s">%s</a></li>`, path, filename, filename)
+		switch {
+		case
+			strings.has_suffix(filename, "_windows.odin"),
+			strings.has_suffix(filename, "_darwin.odin"),
+			strings.has_suffix(filename, "_essence.odin"),
+			strings.has_suffix(filename, "_freebsd.odin"),
+			strings.has_suffix(filename, "_wasi.odin"),
+			strings.has_suffix(filename, "_js.odin"),
+			strings.has_suffix(filename, "_freestanding.odin"),
+
+			strings.has_suffix(filename, "_amd64.odin"),
+			strings.has_suffix(filename, "_i386.odin"),
+			strings.has_suffix(filename, "_arch64.odin"),
+			strings.has_suffix(filename, "_wasm32.odin"),
+			strings.has_suffix(filename, "_wasm64.odin"),
+			false:
+			any_hidden = true
+			continue source_file_loop
+		}
+		fmt.wprintf(w, `<li><a href="%s/%s/%s">%s</a></li>`, GITHUB_CORE_URL, path, filename, filename)
 		fmt.wprintln(w)
 	}
+	if any_hidden {
+		fmt.wprintln(w, "<li><em>(hidden platform specific files)</em></li>")
+	}
 	fmt.wprintln(w, "</ul>")
 
 }
\ No newline at end of file
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index 1f334ad91..61cab3e8c 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -1,3 +1,8 @@
+* {
+	font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";
+}
+
+
 .container {
 	max-width: 60em;
 	margin: 0 auto;
@@ -15,8 +20,11 @@
 }
 
 pre {
-	white-space: pre;
+	white-space: pre-wrap;
+	word-break: break-all;
+	word-wrap: break-word;
 	tab-size: 8;
+	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
 	background-color: #f8f8f8;
 	color: #202224;
 	border: 1px solid #c6c8ca;
@@ -24,12 +32,28 @@ pre {
 	padding: 0.625rem;
 }
 
-.documentation pre a {
+pre a {
+	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
 	text-decoration: none;
-	font-weight: bold;
+	/*font-weight: bold;*/
 	color: #00bfd5;
 }
 
-pre a.code-procedure {
+.documentation pre a.code-procedure {
 	color: #079300;
 }
+
+.documentation-source {
+	text-decoration: none;
+	color: #666666;
+}
+.documentation-source:hover {
+	text-decoration: underline;
+}
+
+a > .a-hidden {
+	opacity: 0;
+}
+a:hover > .a-hidden {
+	opacity: 100;
+}
\ No newline at end of file

From cafb6e5587d4d3f5211b945bcb9d949a3980aa89 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 21:33:20 +0000
Subject: [PATCH 10/37] Correct `//+private` for `odin doc`

---
 src/checker.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/checker.cpp b/src/checker.cpp
index ddb73d33e..44dc90c67 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -3446,6 +3446,13 @@ void check_collect_value_decl(CheckerContext *c, Ast *decl) {
 		}
 	}
 
+	if (entity_visibility_kind == EntityVisiblity_Public &&
+	    (c->scope->flags&ScopeFlag_File) &&
+	    c->scope->file &&
+	    (c->scope->file->flags & AstFile_IsPrivate)) {
+		entity_visibility_kind = EntityVisiblity_PrivateToPackage;
+	}
+
 	if (entity_visibility_kind != EntityVisiblity_Public && !(c->scope->flags&ScopeFlag_File)) {
 		error(decl, "Attribute 'private' is not allowed on a non file scope entity");
 	}

From c7a9c8274fc212ec421d46c2c58f36afdc949898 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 22:16:32 +0000
Subject: [PATCH 11/37] Improve type printing

---
 tools/odin-html-docs/odin_html_docs_main.odin | 243 +++++++++++++-----
 tools/odin-html-docs/style.css                |  32 ++-
 2 files changed, 205 insertions(+), 70 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 4260bd697..988c54d9d 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -45,6 +45,14 @@ base_type :: proc(t: doc.Type) -> doc.Type {
 	return t
 }
 
+is_type_untyped :: proc(type: doc.Type) -> bool {
+	if type.kind == .Basic {
+		flags := transmute(doc.Type_Flags_Basic)type.flags
+		return .Untyped in flags
+	}
+	return false
+}
+
 common_prefix :: proc(strs: []string) -> string {
 	if len(strs) == 0 {
 		return ""
@@ -275,7 +283,9 @@ write_core_directory :: proc(w: io.Writer) {
 			line_doc, _, _ := strings.partition(str(dir.pkg.docs), "\n")
 			line_doc = strings.trim_space(line_doc)
 			if line_doc != "" {
-				fmt.wprintf(w, `<td class="pkg-line-doc">%s</td>`, line_doc)
+				io.write_string(w, `<td class="pkg-line-doc">`)
+				write_doc_line(w, line_doc)
+				io.write_string(w, `</td>`)
 			}
 		}
 		fmt.wprintf(w, "</tr>\n")
@@ -289,7 +299,9 @@ write_core_directory :: proc(w: io.Writer) {
 			line_doc, _, _ := strings.partition(str(child.pkg.docs), "\n")
 			line_doc = strings.trim_space(line_doc)
 			if line_doc != "" {
-				fmt.wprintf(w, `<td class="pkg-line-doc">%s</td>`, line_doc)
+				io.write_string(w, `<td class="pkg-line-doc">`)
+				write_doc_line(w, line_doc)
+				io.write_string(w, `</td>`)
 			}
 
 			fmt.wprintf(w, "</tr>\n")
@@ -305,16 +317,31 @@ is_entity_blank :: proc(e: doc.Entity_Index) -> bool {
 	return name == "" || name == "_"
 }
 
+write_where_clauses :: proc(w: io.Writer, where_clauses: []doc.String) {
+	if len(where_clauses) != 0 {
+		io.write_string(w, " where ")
+		for clause, i in where_clauses {
+			if i > 0 {
+				io.write_string(w, ", ")
+			}
+			io.write_string(w, str(clause))
+		}
+	}
+}
+
+
 Write_Type_Flag :: enum {
 	Is_Results,
 	Variadic,
 	Allow_Indent,
+	Poly_Names,
 }
 Write_Type_Flags :: distinct bit_set[Write_Type_Flag]
 Type_Writer :: struct {
 	w:      io.Writer,
 	pkg:    doc.Pkg_Index,
 	indent: int,
+	generic_scope: map[string]bool,
 }
 
 write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type_Flags) {
@@ -329,30 +356,65 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		if .Param_Any_Int   in e.flags { io.write_string(w, "#any_int ")   }
 
 		init_string := str(e.init_string)
-		switch init_string {
-		case "#caller_location":
+		switch {
+		case init_string == "#caller_location":
 			assert(name != "")
 			io.write_string(w, name)
 			io.write_string(w, " := ")
 			io.write_string(w, `<a href="/core/runtime/#Source_Code_Location">`)
 			io.write_string(w, init_string)
 			io.write_string(w, `</a>`)
-
+		case strings.has_prefix(init_string, "context."):
+			io.write_string(w, name)
+			io.write_string(w, " := ")
+			io.write_string(w, `<a href="/core/runtime/#Context">`)
+			io.write_string(w, init_string)
+			io.write_string(w, `</a>`)
 		case:
-			if name != "" {
-				io.write_string(w, name)
-				io.write_string(w, ": ")
-			}
-			padding := max(name_width-len(name), 0)
-			for _ in 0..<padding {
-				io.write_byte(w, ' ')
+			the_type := types[e.type]
+			type_flags := flags - {.Is_Results}
+			if .Param_Ellipsis in e.flags {
+				type_flags += {.Variadic}
 			}
 
-			param_flags := flags - {.Is_Results}
-			if .Param_Ellipsis in e.flags {
-				param_flags += {.Variadic}
+			#partial switch e.kind {
+			case .Constant:
+				assert(name != "")
+				io.write_byte(w, '$')
+				io.write_string(w, name)
+				generic_scope[name] = true
+				if !is_type_untyped(the_type) {
+					io.write_string(w, ": ")
+					write_type(writer, the_type, type_flags)
+					io.write_string(w, " = ")
+					io.write_string(w, init_string)
+				} else {
+					io.write_string(w, " := ")
+					io.write_string(w, init_string)
+				}
+				return
+
+			case .Variable:
+				if name != "" {
+					io.write_string(w, name)
+					io.write_string(w, ": ")
+				}
+				write_type(writer, the_type, type_flags)
+			case .Type_Name:
+				io.write_byte(w, '$')
+				io.write_string(w, name)
+				generic_scope[name] = true
+				io.write_string(w, ": ")
+				if the_type.kind == .Generic {
+					io.write_string(w, "typeid")
+					if ts := array(the_type.types); len(ts) == 1 {
+						io.write_byte(w, '/')
+						write_type(writer, types[ts[0]], type_flags)
+					}
+				} else {
+					write_type(writer, the_type, type_flags)
+				}
 			}
-			write_type(writer, types[e.type], param_flags)
 
 			if init_string != "" {
 				io.write_string(w, " = ")
@@ -361,14 +423,13 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		}
 	}
 	write_poly_params :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type_Flags) {
-		type_entites := array(type.entities)
-		for entity_index, i in type_entites {
-			if i > 0 {
-				io.write_string(w, ", ")
-			}
-			write_param_entity(writer, &entities[entity_index], flags)
+		if type.polymorphic_params != 0 {
+			io.write_byte(w, '(')
+			write_type(writer, types[type.polymorphic_params], flags+{.Poly_Names})
+			io.write_byte(w, ')')
 		}
-		io.write_byte(w, ')')
+
+		write_where_clauses(w, array(type.where_clauses))
 	}
 	do_indent :: proc(using writer: ^Type_Writer, flags: Write_Type_Flags) {
 		if .Allow_Indent not_in flags {
@@ -400,7 +461,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		// ignore
 	case .Basic:
 		type_flags := transmute(doc.Type_Flags_Basic)type.flags
-		if .Untyped in type_flags {
+		if is_type_untyped(type) {
 			io.write_string(w, str(type.name))
 		} else {
 			fmt.wprintf(w, `<a href="">%s</a>`, str(type.name))
@@ -408,17 +469,23 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 	case .Named:
 		e := entities[type_entites[0]]
 		name := str(type.name)
-		fmt.wprintf(w, `<span>`)
 		tn_pkg := files[e.pos.file].pkg
 		if tn_pkg != pkg {
 			fmt.wprintf(w, `%s.`, str(pkgs[tn_pkg].name))
 		}
-		fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a></span>`, pkg_to_path[&pkgs[tn_pkg]], name)
+		if n := strings.contains_rune(name, '('); n >= 0 {
+			fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name[:n])
+			io.write_string(w, name[n:])
+		} else {
+			fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name)
+		}
 	case .Generic:
 		name := str(type.name)
-		io.write_byte(w, '$')
+		if name not_in generic_scope {
+			io.write_byte(w, '$')
+		}
 		io.write_string(w, name)
-		if len(array(type.types)) == 1 {
+		if name not_in generic_scope && len(array(type.types)) == 1 {
 			io.write_byte(w, '/')
 			write_type(writer, types[type_types[0]], flags)
 		}
@@ -454,9 +521,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 	case .Struct:
 		type_flags := transmute(doc.Type_Flags_Struct)type.flags
 		io.write_string(w, "struct")
-		if .Polymorphic in type_flags {
-			write_poly_params(writer, type, flags)
-		}
+		write_poly_params(writer, type, flags)
 		if .Packed in type_flags { io.write_string(w, " #packed") }
 		if .Raw_Union in type_flags { io.write_string(w, " #raw_union") }
 		if custom_align := str(type.custom_align); custom_align != "" {
@@ -483,9 +548,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 	case .Union:
 		type_flags := transmute(doc.Type_Flags_Union)type.flags
 		io.write_string(w, "union")
-		if .Polymorphic in type_flags {
-			write_poly_params(writer, type, flags)
-		}
+		write_poly_params(writer, type, flags)
 		if .No_Nil in type_flags { io.write_string(w, " #no_nil") }
 		if .Maybe in type_flags { io.write_string(w, " #maybe") }
 		if custom_align := str(type.custom_align); custom_align != "" {
@@ -631,6 +694,25 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 	}
 }
 
+write_doc_line :: proc(w: io.Writer, text: string) {
+	text := text
+	for len(text) != 0 {
+		if strings.count(text, "`") >= 2 {
+			n := strings.index_byte(text, '`')
+			io.write_string(w, text[:n])
+			io.write_string(w, "<code class=\"code-inline\">")
+			remaining := text[n+1:]
+			m := strings.index_byte(remaining, '`')
+			io.write_string(w, remaining[:m])
+			io.write_string(w, "</code>")
+			text = remaining[m+1:]
+		} else {
+			io.write_string(w, text)
+			return
+		}
+	}
+}
+
 write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 	if docs == "" {
 		return
@@ -663,8 +745,11 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 			fmt.wprintln(w, "<p>")
 		}
 		assert(!was_code)
+
 		was_paragraph = true
-		fmt.wprintln(w, text)
+		write_doc_line(w, text)
+
+		io.write_byte(w, '\n')
 	}
 	if was_code {
 		// assert(!was_paragraph, str(pkg.name))
@@ -677,6 +762,24 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 }
 
 write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
+	write_breadcrumbs :: proc(w: io.Writer, path: string) {
+		dirs := strings.split(path, "/")
+		io.write_string(w, "<ul class=\"documentation-breadcrumb\">\n")
+		for dir, i in dirs {
+			url := strings.join(dirs[:i+1], "/")
+			short_path := strings.join(dirs[1:i+1], "/")
+			if i == 0 || short_path in pkgs_to_use {
+				fmt.wprintf(w, "<li><a href=\"/%s\">%s</a></li>", url, dir)
+			} else {
+				fmt.wprintf(w, "<li>%s</li>", dir)
+			}
+		}
+		io.write_string(w, "</ul>\n")
+
+	}
+	write_breadcrumbs(w, fmt.tprintf("core/%s", path))
+
+
 	fmt.wprintf(w, "<h1>package core:%s</h1>\n", path)
 	fmt.wprintln(w, "<h2>Documentation</h2>")
 	docs := strings.trim_space(str(pkg.docs))
@@ -723,7 +826,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	slice.sort_by_key(pkg_vars[:],        entity_key)
 	slice.sort_by_key(pkg_consts[:],      entity_key)
 
-	print_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
+	write_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
 		fmt.wprintf(w, "<h4>%s</h4>\n", name)
 		fmt.wprintln(w, `<section class="documentation-index">`)
 		if len(entities) == 0 {
@@ -740,16 +843,16 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	}
 
 
-	print_index(w, "Procedures",       pkg_procs[:])
-	print_index(w, "Procedure Groups", pkg_proc_groups[:])
-	print_index(w, "Types",            pkg_types[:])
-	print_index(w, "Variables",        pkg_vars[:])
-	print_index(w, "Constants",        pkg_consts[:])
+	write_index(w, "Procedures",       pkg_procs[:])
+	write_index(w, "Procedure Groups", pkg_proc_groups[:])
+	write_index(w, "Types",            pkg_types[:])
+	write_index(w, "Variables",        pkg_vars[:])
+	write_index(w, "Constants",        pkg_consts[:])
 
 	fmt.wprintln(w, "</section>")
 
 
-	print_entity :: proc(w: io.Writer, e: ^doc.Entity) {
+	write_entity :: proc(w: io.Writer, e: ^doc.Entity) {
 		write_attributes :: proc(w: io.Writer, e: ^doc.Entity) {
 			for attr in array(e.attributes) {
 				io.write_string(w, "@(")
@@ -764,23 +867,24 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			}
 		}
 
-
 		pkg_index := files[e.pos.file].pkg
 		pkg := &pkgs[pkg_index]
 		writer := &Type_Writer{
 			w = w,
 			pkg = pkg_index,
 		}
+		defer delete(writer.generic_scope)
 
 		name := str(e.name)
 		path := pkg_to_path[pkg]
 		filename := slashpath.base(str(files[e.pos.file].name))
-		fmt.wprintf(w, "<h4 id=\"{0:s}\"><span><a class=\"documentation-id-link\" href=\"#%s\">{0:s}", name)
-		fmt.wprintf(w, "<span class=\"a-hidden\">&nbsp;¶</span></a></span></h4>\n")
-		defer if e.pos.file != 0 && e.pos.line > 0 {
+		fmt.wprintf(w, "<h4 id=\"{0:s}\"><span><a class=\"documentation-id-link\" href=\"#{0:s}\">{0:s}", name)
+		fmt.wprintf(w, "<span class=\"a-hidden\">&nbsp;¶</span></a></span>")
+		if e.pos.file != 0 && e.pos.line > 0 {
 			src_url := fmt.tprintf("%s/%s/%s#L%d", GITHUB_CORE_URL, path, filename, e.pos.line)
-			fmt.wprintf(w, "<a class=\"documentation-source\" href=\"{0:s}\"><em>Source:&nbsp;{0:s}</em></a>", src_url)
+			fmt.wprintf(w, "<div class=\"documentation-source\"><a href=\"{0:s}\"><em>Source</em></a></div>", src_url)
 		}
+		fmt.wprintf(w, "</h4>\n")
 
 		switch e.kind {
 		case .Invalid, .Import_Name, .Library_Name:
@@ -788,7 +892,21 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		case .Constant:
 			fmt.wprint(w, "<pre>")
 			the_type := types[e.type]
-			if the_type.kind == .Basic && .Untyped in (transmute(doc.Type_Flags_Basic)the_type.flags) {
+
+			init_string := str(e.init_string)
+			assert(init_string != "")
+
+			ignore_type := true
+			if the_type.kind == .Basic && is_type_untyped(the_type) {
+			} else {
+				ignore_type = false
+				type_name := str(the_type.name)
+				if type_name != "" && strings.has_prefix(init_string, type_name) {
+					ignore_type = true
+				}
+			}
+
+			if ignore_type {
 				fmt.wprintf(w, "%s :: ", name)
 			} else {
 				fmt.wprintf(w, "%s: ", name)
@@ -796,8 +914,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 				fmt.wprintf(w, " : ")
 			}
 
-			init_string := str(e.init_string)
-			assert(init_string != "")
+
 			io.write_string(w, init_string)
 			fmt.wprintln(w, "</pre>")
 		case .Variable:
@@ -835,17 +952,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprint(w, "<pre>")
 			fmt.wprintf(w, "%s :: ", name)
 			write_type(writer, types[e.type], nil)
-			where_clauses := array(e.where_clauses)
-			if len(where_clauses) != 0 {
-				io.write_string(w, " where ")
-				for clause, i in where_clauses {
-					if i > 0 {
-						io.write_string(w, ", ")
-					}
-					io.write_string(w, str(clause))
-				}
-			}
-
+			write_where_clauses(w, array(e.where_clauses))
 			fmt.wprint(w, " {…}")
 			fmt.wprintln(w, "</pre>")
 		case .Proc_Group:
@@ -872,24 +979,24 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 
 		write_docs(w, pkg, strings.trim_space(str(e.docs)))
 	}
-	print_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
+	write_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
 		fmt.wprintf(w, "<h3>%s</h3>\n", title)
 		fmt.wprintln(w, `<section class="documentation">`)
 		if len(entities) == 0 {
 			io.write_string(w, "<p>This section is empty.</p>\n")
 		} else {
 			for e in entities {
-				print_entity(w, e)
+				write_entity(w, e)
 			}
 		}
 		fmt.wprintln(w, "</section>")
 	}
 
-	print_entities(w, "Procedures",       pkg_procs[:])
-	print_entities(w, "Procedure Groups", pkg_proc_groups[:])
-	print_entities(w, "Types",            pkg_types[:])
-	print_entities(w, "Variables",        pkg_vars[:])
-	print_entities(w, "Constants",        pkg_consts[:])
+	write_entities(w, "Procedures",       pkg_procs[:])
+	write_entities(w, "Procedure Groups", pkg_proc_groups[:])
+	write_entities(w, "Types",            pkg_types[:])
+	write_entities(w, "Variables",        pkg_vars[:])
+	write_entities(w, "Constants",        pkg_consts[:])
 
 
 	fmt.wprintln(w, "<h3>Source Files</h3>")
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index 61cab3e8c..cf43a7199 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -21,7 +21,7 @@
 
 pre {
 	white-space: pre-wrap;
-	word-break: break-all;
+	word-break: keep-all;
 	word-wrap: break-word;
 	tab-size: 8;
 	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
@@ -44,10 +44,15 @@ pre a {
 }
 
 .documentation-source {
+	display: inline;
+	float: right;
+}
+
+.documentation-source a {
 	text-decoration: none;
 	color: #666666;
 }
-.documentation-source:hover {
+.documentation-source a:hover {
 	text-decoration: underline;
 }
 
@@ -56,4 +61,27 @@ a > .a-hidden {
 }
 a:hover > .a-hidden {
 	opacity: 100;
+}
+
+ul.documentation-breadcrumb {
+	list-style: none;
+}
+
+ul.documentation-breadcrumb li {
+	display: inline;
+}
+
+ul.documentation-breadcrumb li+li:before {
+	padding: 0.2rem;
+	color: black;
+	content:  "/\00a0";
+}
+
+.code-inline {
+	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
+	background-color: #f8f8f8;
+	color: #202224;
+	border: 1px solid #c6c8ca;
+	border-radius: 0.25rem;
+	padding: 0.125rem;
 }
\ No newline at end of file

From fb01dfe04845a489760956cea4f0019e1464b2e3 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 22:17:07 +0000
Subject: [PATCH 12/37] Improve docs_writer.cpp

---
 core/math/big/doc.odin      | 22 ----------------------
 core/math/big/internal.odin | 24 +++++++++++++++++++++++-
 core/math/big/tune.odin     |  3 +--
 src/docs_writer.cpp         |  2 +-
 src/types.cpp               | 14 +++++---------
 5 files changed, 30 insertions(+), 35 deletions(-)

diff --git a/core/math/big/doc.odin b/core/math/big/doc.odin
index f5e0900f5..0f9b88d01 100644
--- a/core/math/big/doc.odin
+++ b/core/math/big/doc.odin
@@ -2,27 +2,5 @@
 A BigInt implementation in Odin.
 For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
 The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
-==========================    Low-level routines    ==========================
-
-IMPORTANT: `internal_*` procedures make certain assumptions about their input.
-
-The public functions that call them are expected to satisfy their sanity check requirements.
-This allows `internal_*` call `internal_*` without paying this overhead multiple times.
-
-Where errors can occur, they are of course still checked and returned as appropriate.
-
-When importing `math:core/big` to implement an involved algorithm of your own, you are welcome
-to use these procedures instead of their public counterparts.
-
-Most inputs and outputs are expected to be passed an initialized `Int`, for example.
-Exceptions include `quotient` and `remainder`, which are allowed to be `nil` when the calling code doesn't need them.
-
-Check the comments above each `internal_*` implementation to see what constraints it expects to have met.
-
-We pass the custom allocator to procedures by default using the pattern `context.allocator = allocator`.
-This way we don't have to add `, allocator` at the end of each call.
-
-TODO: Handle +/- Infinity and NaN.
 */
 package math_big
diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin
index 5085898e5..dbcd16509 100644
--- a/core/math/big/internal.odin
+++ b/core/math/big/internal.odin
@@ -1,10 +1,32 @@
-//+ignore
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
+
+	==========================    Low-level routines    ==========================
+
+	IMPORTANT: `internal_*` procedures make certain assumptions about their input.
+
+	The public functions that call them are expected to satisfy their sanity check requirements.
+	This allows `internal_*` call `internal_*` without paying this overhead multiple times.
+
+	Where errors can occur, they are of course still checked and returned as appropriate.
+
+	When importing `math:core/big` to implement an involved algorithm of your own, you are welcome
+	to use these procedures instead of their public counterparts.
+
+	Most inputs and outputs are expected to be passed an initialized `Int`, for example.
+	Exceptions include `quotient` and `remainder`, which are allowed to be `nil` when the calling code doesn't need them.
+
+	Check the comments above each `internal_*` implementation to see what constraints it expects to have met.
+
+	We pass the custom allocator to procedures by default using the pattern `context.allocator = allocator`.
+	This way we don't have to add `, allocator` at the end of each call.
+
+	TODO: Handle +/- Infinity and NaN.
 */
 
 
+//+ignore
 package math_big
 
 import "core:mem"
diff --git a/core/math/big/tune.odin b/core/math/big/tune.odin
index 64a73b656..78a20c12b 100644
--- a/core/math/big/tune.odin
+++ b/core/math/big/tune.odin
@@ -1,4 +1,3 @@
-//+ignore
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
@@ -8,7 +7,7 @@
 	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
 
-
+//+ignore
 package math_big
 
 import "core:time"
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index 94b43be99..762a2afe1 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -513,7 +513,7 @@ OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 		break;
 	case Type_Generic:
 		doc_type.kind = OdinDocType_Generic;
-		doc_type.name = odin_doc_write_string(w, type->Generic.name);
+		doc_type.name = odin_doc_write_string(w, type->Generic.entity->token.string);
 		if (type->Generic.specialized) {
 			doc_type.types = odin_doc_type_as_slice(w, type->Generic.specialized);
 		}
diff --git a/src/types.cpp b/src/types.cpp
index f621d4346..6162a5aa8 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -3933,7 +3933,7 @@ gbString write_type_to_string(gbString str, Type *type) {
 						str = gb_string_appendc(str, " = ");
 						str = write_exact_value_to_string(str, var->Constant.value);
 					} else {
-						str = gb_string_appendc(str, "=");
+						str = gb_string_appendc(str, " := ");
 						str = write_exact_value_to_string(str, var->Constant.value);
 					}
 					continue;
@@ -3961,14 +3961,10 @@ gbString write_type_to_string(gbString str, Type *type) {
 						str = gb_string_appendc(str, "typeid/");
 						str = write_type_to_string(str, var->type);
 					} else {
-						if (var->kind == Entity_TypeName) {
-							str = gb_string_appendc(str, "$");
-							str = gb_string_append_length(str, name.text, name.len);
-							str = gb_string_appendc(str, "=");
-							str = write_type_to_string(str, var->type);
-						} else {
-							str = gb_string_appendc(str, "typeid");
-						}
+						str = gb_string_appendc(str, "$");
+						str = gb_string_append_length(str, name.text, name.len);
+						str = gb_string_appendc(str, "=");
+						str = write_type_to_string(str, var->type);
 					}
 				}
 			}

From 6b830f42b6a8baec77ee0c8d12333ca2ad4a296f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Jan 2022 23:48:46 +0000
Subject: [PATCH 13/37] Improve stylization with collapsible directories; Fix
 name padding

---
 tools/odin-html-docs/odin_html_docs_main.odin | 75 ++++++++++++++++---
 tools/odin-html-docs/style.css                | 63 ++++++++++++++--
 2 files changed, 121 insertions(+), 17 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 988c54d9d..317d95a5a 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -107,6 +107,51 @@ write_html_header :: proc(w: io.Writer, title: string) {
 }
 
 write_html_footer :: proc(w: io.Writer) {
+	io.write_string(w, `
+	<script type="text/javascript">
+	(function (win, doc) {
+		'use strict';
+		if (!doc.querySelectorAll || !win.addEventListener) {
+			// doesn't cut the mustard.
+			return;
+		}
+		let toggles = doc.querySelectorAll('[aria-controls]');
+		for (let i = 0; i < toggles.length; i = i + 1) {
+			let toggleID = toggles[i].getAttribute('aria-controls');
+			if (doc.getElementById(toggleID)) {
+				let togglecontent = doc.getElementById(toggleID);
+				togglecontent.setAttribute('aria-hidden', 'true');
+				togglecontent.setAttribute('tabindex', '-1');
+				toggles[i].setAttribute('aria-expanded', 'false');
+			}
+		}
+		function toggle(ev) {
+			ev = ev || win.event;
+			var target = ev.target || ev.srcElement;
+			if (target.hasAttribute('data-aria-owns')) {
+				let toggleIDs = target.getAttribute('data-aria-owns').match(/[^ ]+/g);
+				toggleIDs.forEach(toggleID => {
+					if (doc.getElementById(toggleID)) {
+						ev.preventDefault();
+						let togglecontent = doc.getElementById(toggleID);
+						if (togglecontent.getAttribute('aria-hidden') == 'true') {
+							togglecontent.setAttribute('aria-hidden', 'false');
+							target.setAttribute('aria-expanded', 'true');
+							if (target.tagName == 'A') {
+								togglecontent.focus();
+							}
+						} else {
+							togglecontent.setAttribute('aria-hidden', 'true');
+							target.setAttribute('aria-expanded', 'false');
+						}
+					}
+				})
+			}
+		}
+		doc.addEventListener('click', toggle, false);
+	}(this, this.document));
+	</script>
+`)
 	fmt.wprintf(w, "</div></body>\n</html>\n")
 }
 
@@ -255,7 +300,7 @@ write_core_directory :: proc(w: io.Writer) {
 
 	fmt.wprintln(w, "<h2>Directories</h2>")
 
-	fmt.wprintln(w, "\t<table>")
+	fmt.wprintln(w, "\t<table class=\"documentation-directory\">")
 	fmt.wprintln(w, "\t\t<tbody>")
 
 	for dir := root.first_child; dir != nil; dir = dir.next {
@@ -264,7 +309,7 @@ write_core_directory :: proc(w: io.Writer) {
 			for child := dir.first_child; child != nil; child = child.next {
 				fmt.wprintf(w, "pkg-%s ", str(child.pkg.name))
 			}
-			fmt.wprint(w, `" class="directory-pkg"><td class="pkg-name" data-aria-owns="`)
+			fmt.wprint(w, `" class="directory-pkg"><td class="pkg-line pkg-name" data-aria-owns="`)
 			for child := dir.first_child; child != nil; child = child.next {
 				fmt.wprintf(w, "pkg-%s ", str(child.pkg.name))
 			}
@@ -278,32 +323,33 @@ write_core_directory :: proc(w: io.Writer) {
 		} else {
 			fmt.wprintf(w, "%s", dir.name)
 		}
-		fmt.wprintf(w, "</td>")
+		io.write_string(w, `</td>`)
+		io.write_string(w, `<td class="pkg-line pkg-line-doc">`)
 		if dir.pkg != nil {
 			line_doc, _, _ := strings.partition(str(dir.pkg.docs), "\n")
 			line_doc = strings.trim_space(line_doc)
 			if line_doc != "" {
-				io.write_string(w, `<td class="pkg-line-doc">`)
 				write_doc_line(w, line_doc)
-				io.write_string(w, `</td>`)
 			}
 		}
+		io.write_string(w, `</td>`)
 		fmt.wprintf(w, "</tr>\n")
 
 		for child := dir.first_child; child != nil; child = child.next {
 			assert(child.pkg != nil)
-			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg directory-child"><td class="pkg-name">`, str(child.pkg.name))
+			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg directory-child"><td class="pkg-line pkg-name">`, str(child.pkg.name))
 			fmt.wprintf(w, `<a href="/core/%s/">%s</a>`, child.path, child.name)
-			fmt.wprintf(w, "</td>")
+			io.write_string(w, `</td>`)
 
 			line_doc, _, _ := strings.partition(str(child.pkg.docs), "\n")
 			line_doc = strings.trim_space(line_doc)
+			io.write_string(w, `<td class="pkg-line pkg-line-doc">`)
 			if line_doc != "" {
-				io.write_string(w, `<td class="pkg-line-doc">`)
 				write_doc_line(w, line_doc)
-				io.write_string(w, `</td>`)
 			}
+			io.write_string(w, `</td>`)
 
+			fmt.wprintf(w, "</td>")
 			fmt.wprintf(w, "</tr>\n")
 		}
 	}
@@ -314,7 +360,7 @@ write_core_directory :: proc(w: io.Writer) {
 
 is_entity_blank :: proc(e: doc.Entity_Index) -> bool {
 	name := str(entities[e].name)
-	return name == "" || name == "_"
+	return name == ""
 }
 
 write_where_clauses :: proc(w: io.Writer, where_clauses: []doc.String) {
@@ -348,6 +394,12 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 	write_param_entity :: proc(using writer: ^Type_Writer, e: ^doc.Entity, flags: Write_Type_Flags, name_width := 0) {
 		name := str(e.name)
 
+		write_padding :: proc(w: io.Writer, name: string, name_width: int) {
+			for _ in 0..<name_width-len(name) {
+				io.write_byte(w, ' ')
+			}
+		}
+
 		if .Param_Using     in e.flags { io.write_string(w, "using ")      }
 		if .Param_Const     in e.flags { io.write_string(w, "#const ")     }
 		if .Param_Auto_Cast in e.flags { io.write_string(w, "#auto_cast ") }
@@ -385,6 +437,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 				generic_scope[name] = true
 				if !is_type_untyped(the_type) {
 					io.write_string(w, ": ")
+					write_padding(w, name, name_width)
 					write_type(writer, the_type, type_flags)
 					io.write_string(w, " = ")
 					io.write_string(w, init_string)
@@ -398,6 +451,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 				if name != "" {
 					io.write_string(w, name)
 					io.write_string(w, ": ")
+					write_padding(w, name, name_width)
 				}
 				write_type(writer, the_type, type_flags)
 			case .Type_Name:
@@ -405,6 +459,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 				io.write_string(w, name)
 				generic_scope[name] = true
 				io.write_string(w, ": ")
+				write_padding(w, name, name_width)
 				if the_type.kind == .Generic {
 					io.write_string(w, "typeid")
 					if ts := array(the_type.types); len(ts) == 1 {
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index cf43a7199..c83a046a8 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -1,22 +1,54 @@
-* {
+html {
 	font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";
 }
 
-
 .container {
 	max-width: 60em;
 	margin: 0 auto;
 	padding-left: 0.01em 1em;
 }
 
-.directory-pkg {
-	width: 20em;
+table.documentation-directory {
+	/*border: 1px solid #ccc!important;*/
+	table-layout: fixed;
+	border-collapse: collapse;
 }
 
-.directory-child .pkg-name {
+.documentation-directory tr {
+	padding-left: 1em!important;
+	border-top: 1px solid #ccc!important;
+	border-bottom: 1px solid #ccc!important;
+}
+
+.documentation-directory td {
+	padding: 0.25em 0.5em;
+}
+.directory-child td {
+	padding-left: 2em!important;
+}
+
+.directory-child td+td {
 	position: relative;
-	left: 2em;
-	width: 18em;
+	left: -1.5em!important;
+	padding-right: 0;
+}
+.pkg-line-doc {
+	color: #444;
+}
+
+.documentation-directory tr[aria-controls]:hover {
+	background-color: #eee;
+}
+
+.documentation-directory tr[aria-expanded=true] td.pkg-name:before {
+	content: "\2193";
+}
+.documentation-directory tr[aria-expanded=false] td.pkg-name:before {
+	content: "\2192"!important;
+}
+
+.documentation-directory tr[aria-hidden=true] {
+	display: none;
 }
 
 pre {
@@ -84,4 +116,21 @@ ul.documentation-breadcrumb li+li:before {
 	border: 1px solid #c6c8ca;
 	border-radius: 0.25rem;
 	padding: 0.125rem;
+}
+
+.documentation-directory {
+	width:  100%;
+}
+
+.documentation-directory tr {
+	/*background-color: #999;*/
+}
+
+
+.documentation-directory tr[aria-controls] {
+	cursor: pointer;
+}
+
+.documentation-directory tr.hidden {
+	display: none;
 }
\ No newline at end of file

From db08847f9ab8090c246f678b3b440fc3e6aacd4c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 13:20:38 +0000
Subject: [PATCH 14/37] Improve rendering to match the main website's CSS

---
 tools/odin-html-docs/footer.txt.html          |  43 ++++
 tools/odin-html-docs/header.txt.html          |  34 +++
 tools/odin-html-docs/odin_html_docs_main.odin | 226 +++++++++++-------
 tools/odin-html-docs/style.css                |  89 ++-----
 4 files changed, 241 insertions(+), 151 deletions(-)
 create mode 100644 tools/odin-html-docs/footer.txt.html
 create mode 100644 tools/odin-html-docs/header.txt.html

diff --git a/tools/odin-html-docs/footer.txt.html b/tools/odin-html-docs/footer.txt.html
new file mode 100644
index 000000000..fbed3146a
--- /dev/null
+++ b/tools/odin-html-docs/footer.txt.html
@@ -0,0 +1,43 @@
+</div>
+</main>
+
+<footer class="odin-footer">
+	<div class="container pb-5 pt-5">
+		<div class="row g-4">
+		<div class="col">
+		<a class="navbar-brand" href="//odin-lang.org">
+		<img class="mb-3" src="//odin-lang.org/logo.svg" height="30" alt="Odin"></a>
+		<p>
+		The Data-Oriented Language for Sane Software Development.
+		</p>
+		</div>
+		<nav class="col-md-auto">
+			<h4 class="fw-normal">Resources</h4>
+			<ul class="list-unstyled">
+			<li><a href="//odin-lang.org/docs" class="link-light">Docs</a></li>
+			<li><a href="//odin-lang.org/news" class="link-light">Blog</a></li>
+			</ul>
+		</nav>
+		<nav class="col-md-auto">
+			<h4 class="fw-normal">Community</h4>
+			<ul class="list-unstyled">
+			<li><a href="https://github.com/odin-lang/Odin" target="_blank" class="link-light">GitHub</a></li>
+			<li><a href="https://discord.com/invite/sVBPHEv" target="_blank" class="link-light">Discord</a></li>
+			<li><a href="https://www.twitch.tv/ginger_bill" target="_blank" class="link-light">Twitch</a></li>
+			<li><a href="https://www.youtube.com/channel/UCUSck1dOH7VKmG4lRW7tZXg" target="_blank" class="link-light">YouTube</a></li>
+			</ul>
+		</nav>
+		<nav class="col-md-auto">
+			<h4 class="fw-normal">Contribute</h4>
+			<ul class="list-unstyled">
+			<li><a href="https://github.com/odin-lang/Odin/issues" target="_blank" class="link-light">Issues</a></li>
+			<li><a href="https://www.patreon.com/gingerbill" target="_blank" class="link-light">Donate</a></li>
+			</ul>
+			</nav>
+		</div>
+		<div class="mt-4 text-muted">© 2016–2022 Ginger Bill</div>
+	</div>
+</footer>
+
+<script src="//odin-lang.org/lib/bootstrap/js/bootstrap.min.js"></script>
+<script src="//odin-lang.org/js/script.js"></script>
\ No newline at end of file
diff --git a/tools/odin-html-docs/header.txt.html b/tools/odin-html-docs/header.txt.html
new file mode 100644
index 000000000..cfa1e0175
--- /dev/null
+++ b/tools/odin-html-docs/header.txt.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<title>{0:s}</title>
+
+	<script type="text/javascript" src="https://livejs.com/live.js"></script>
+
+	<link rel="stylesheet" type="text/css" href="https://odin-lang.org/scss/custom.min.css">
+	<link rel="stylesheet" type="text/css" href="https://odin-lang.org/css/style.css">
+	<link rel="stylesheet" type="text/css" href="/style.css">
+
+	</style>
+</head>
+<body>
+<header class="sticky-top">
+	<nav class="navbar navbar-expand-lg navbar-dark bg-primary odin-menu">
+		<div class="container">
+			<a class="navbar-brand" href="/core">
+			<img src="//odin-lang.org/logo.svg" height="30" alt="Odin"></a>
+			<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#odin-navbar-content" aria-controls="odin-navbar-content" aria-expanded="false" aria-label="Toggle navigation"><span class="navbar-toggler-icon"></span></button>
+			<div class="collapse navbar-collapse" id="odin-navbar-content">
+			<ul class="navbar-nav ms-md-auto">
+				<li class="nav-item"><a class="nav-link" href="/core">Home</a></li>
+				<li class="nav-item"><a class="nav-link active" href="//odin-lang.org" aria-current="page">Language</a></li>
+				<li class="nav-item"><a class="nav-link" href="https://github.com/odin-lang/Odin" target="_blank">GitHub</a></li>
+			</ul>
+		</div>
+		</div>
+	</nav>
+</header>
+<main>
+<div class="container">
\ No newline at end of file
diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 317d95a5a..a6b5f428e 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -88,71 +88,62 @@ recursive_make_directory :: proc(path: string, prefix := "") {
 
 
 write_html_header :: proc(w: io.Writer, title: string) {
-	fmt.wprintf(w, `<!DOCTYPE html>
-<html>
-<head>
-	<meta charset="utf-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1">
-	<title>%s</title>
-
-	<script type="text/javascript" src="https://livejs.com/live.js"></script>
-	<link rel="stylesheet" type="text/css" href="/style.css">
-
-	</style>
-</head>
-<body>`, title)
-	fmt.wprintln(w, "\n<div class=\"container\">")
-	fmt.wprintln(w, "\n<a href=\"/core\">Core Directory</a>")
-
+	fmt.wprintf(w, string(#load("header.txt.html")), title)
 }
 
-write_html_footer :: proc(w: io.Writer) {
-	io.write_string(w, `
-	<script type="text/javascript">
-	(function (win, doc) {
-		'use strict';
-		if (!doc.querySelectorAll || !win.addEventListener) {
-			// doesn't cut the mustard.
-			return;
+write_html_footer :: proc(w: io.Writer, include_directory_js: bool) {
+	fmt.wprintf(w, "\n")
+
+	io.write(w, #load("footer.txt.html"))
+
+	if include_directory_js {
+		io.write_string(w, `
+<script type="text/javascript">
+(function (win, doc) {
+	'use strict';
+	if (!doc.querySelectorAll || !win.addEventListener) {
+		// doesn't cut the mustard.
+		return;
+	}
+	let toggles = doc.querySelectorAll('[aria-controls]');
+	for (let i = 0; i < toggles.length; i = i + 1) {
+		let toggleID = toggles[i].getAttribute('aria-controls');
+		if (doc.getElementById(toggleID)) {
+			let togglecontent = doc.getElementById(toggleID);
+			togglecontent.setAttribute('aria-hidden', 'true');
+			togglecontent.setAttribute('tabindex', '-1');
+			toggles[i].setAttribute('aria-expanded', 'false');
 		}
-		let toggles = doc.querySelectorAll('[aria-controls]');
-		for (let i = 0; i < toggles.length; i = i + 1) {
-			let toggleID = toggles[i].getAttribute('aria-controls');
-			if (doc.getElementById(toggleID)) {
-				let togglecontent = doc.getElementById(toggleID);
-				togglecontent.setAttribute('aria-hidden', 'true');
-				togglecontent.setAttribute('tabindex', '-1');
-				toggles[i].setAttribute('aria-expanded', 'false');
-			}
-		}
-		function toggle(ev) {
-			ev = ev || win.event;
-			var target = ev.target || ev.srcElement;
-			if (target.hasAttribute('data-aria-owns')) {
-				let toggleIDs = target.getAttribute('data-aria-owns').match(/[^ ]+/g);
-				toggleIDs.forEach(toggleID => {
-					if (doc.getElementById(toggleID)) {
-						ev.preventDefault();
-						let togglecontent = doc.getElementById(toggleID);
-						if (togglecontent.getAttribute('aria-hidden') == 'true') {
-							togglecontent.setAttribute('aria-hidden', 'false');
-							target.setAttribute('aria-expanded', 'true');
-							if (target.tagName == 'A') {
-								togglecontent.focus();
-							}
-						} else {
-							togglecontent.setAttribute('aria-hidden', 'true');
-							target.setAttribute('aria-expanded', 'false');
+	}
+	function toggle(ev) {
+		ev = ev || win.event;
+		var target = ev.target || ev.srcElement;
+		if (target.hasAttribute('data-aria-owns')) {
+			let toggleIDs = target.getAttribute('data-aria-owns').match(/[^ ]+/g);
+			toggleIDs.forEach(toggleID => {
+				if (doc.getElementById(toggleID)) {
+					ev.preventDefault();
+					let togglecontent = doc.getElementById(toggleID);
+					if (togglecontent.getAttribute('aria-hidden') == 'true') {
+						togglecontent.setAttribute('aria-hidden', 'false');
+						target.setAttribute('aria-expanded', 'true');
+						if (target.tagName == 'A') {
+							togglecontent.focus();
 						}
+					} else {
+						togglecontent.setAttribute('aria-hidden', 'true');
+						target.setAttribute('aria-expanded', 'false');
 					}
-				})
-			}
+				}
+			})
 		}
-		doc.addEventListener('click', toggle, false);
-	}(this, this.document));
-	</script>
-`)
-	fmt.wprintf(w, "</div></body>\n</html>\n")
+	}
+	doc.addEventListener('click', toggle, false);
+}(this, this.document));
+</script>`)
+	}
+
+	fmt.wprintf(w, "</body>\n</html>\n")
 }
 
 main :: proc() {
@@ -220,7 +211,7 @@ main :: proc() {
 		strings.reset_builder(&b)
 		write_html_header(w, "core library - pkg.odin-lang.org")
 		write_core_directory(w)
-		write_html_footer(w)
+		write_html_footer(w, true)
 		os.make_directory("core", 0)
 		os.write_entire_file("core/index.html", b.buf[:])
 	}
@@ -229,7 +220,7 @@ main :: proc() {
 		strings.reset_builder(&b)
 		write_html_header(w, fmt.tprintf("package %s - pkg.odin-lang.org", path))
 		write_pkg(w, path, pkg)
-		write_html_footer(w)
+		write_html_footer(w, false)
 		recursive_make_directory(path, "core")
 		os.write_entire_file(fmt.tprintf("core/%s/index.html", path), b.buf[:])
 	}
@@ -297,10 +288,19 @@ write_core_directory :: proc(w: io.Writer) {
 		}
 	}
 
+	fmt.wprintln(w, `<div class="row odin-main">`)
+	defer fmt.wprintln(w, `</div>`)
+	fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
+	defer fmt.wprintln(w, `</article>`)
 
-	fmt.wprintln(w, "<h2>Directories</h2>")
+	fmt.wprintln(w, "<article>")
+	fmt.wprintln(w, "<header>")
+	fmt.wprintln(w, "<h1>Core Library Collection</h1>")
+	fmt.wprintln(w, "</header>")
+	fmt.wprintln(w, "</article>")
 
-	fmt.wprintln(w, "\t<table class=\"documentation-directory\">")
+	fmt.wprintln(w, "<div>")
+	fmt.wprintln(w, "\t<table class=\"doc-directory mt-4 mb-4\">")
 	fmt.wprintln(w, "\t\t<tbody>")
 
 	for dir := root.first_child; dir != nil; dir = dir.next {
@@ -356,6 +356,7 @@ write_core_directory :: proc(w: io.Writer) {
 
 	fmt.wprintln(w, "\t\t</tbody>")
 	fmt.wprintln(w, "\t</table>")
+	fmt.wprintln(w, "</div>")
 }
 
 is_entity_blank :: proc(e: doc.Entity_Index) -> bool {
@@ -817,23 +818,42 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 }
 
 write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
-	write_breadcrumbs :: proc(w: io.Writer, path: string) {
-		dirs := strings.split(path, "/")
-		io.write_string(w, "<ul class=\"documentation-breadcrumb\">\n")
-		for dir, i in dirs {
-			url := strings.join(dirs[:i+1], "/")
-			short_path := strings.join(dirs[1:i+1], "/")
-			if i == 0 || short_path in pkgs_to_use {
-				fmt.wprintf(w, "<li><a href=\"/%s\">%s</a></li>", url, dir)
-			} else {
-				fmt.wprintf(w, "<li>%s</li>", dir)
+
+
+	fmt.wprintln(w, `<div class="row odin-main">`)
+	defer fmt.wprintln(w, `</div>`)
+
+	{ // breadcrumbs
+		fmt.wprintln(w, `<nav class="col-lg-2 odin-side-bar-border navbar-light">`)
+		fmt.wprintln(w, `<div class="sticky-top odin-below-navbar py-3">`)
+		{
+			dirs := strings.split(path, "/")
+			io.write_string(w, "<ul class=\"nav nav-pills d-flex flex-column\">\n")
+			io.write_string(w, `<li class="nav-item"><a class="nav-link" href="/core">core</a></li>`)
+			for dir, i in dirs {
+				url := strings.join(dirs[:i+1], "/")
+				short_path := strings.join(dirs[1:i+1], "/")
+
+				io.write_string(w, `<li class="nav-item">`)
+				a_class := "nav-link"
+				if i+1 == len(dirs) {
+					a_class = "nav-link active"
+				}
+
+				if i == 0 || short_path in pkgs_to_use {
+					fmt.wprintf(w, `<a class="%s" href="/core/%s">%s</a></li>` + "\n", a_class, url, dir)
+				} else {
+					fmt.wprintf(w, "%s</li>\n", dir)
+				}
 			}
+			io.write_string(w, "</ul>\n")
 		}
-		io.write_string(w, "</ul>\n")
 
+		fmt.wprintln(w, `</div>`)
+		fmt.wprintln(w, `</nav>`)
 	}
-	write_breadcrumbs(w, fmt.tprintf("core/%s", path))
 
+	fmt.wprintln(w, `<article class="col-lg-8 p-4">`)
 
 	fmt.wprintf(w, "<h1>package core:%s</h1>\n", path)
 	fmt.wprintln(w, "<h2>Documentation</h2>")
@@ -847,7 +867,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	}
 
 	fmt.wprintln(w, "<h3>Index</h3>")
-	fmt.wprintln(w, `<section class="documentation-index">`)
+	fmt.wprintln(w, `<section class="doc-index">`)
 	pkg_procs:       [dynamic]^doc.Entity
 	pkg_proc_groups: [dynamic]^doc.Entity
 	pkg_types:       [dynamic]^doc.Entity
@@ -883,7 +903,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 
 	write_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
 		fmt.wprintf(w, "<h4>%s</h4>\n", name)
-		fmt.wprintln(w, `<section class="documentation-index">`)
+		fmt.wprintln(w, `<section class="doc-index">`)
 		if len(entities) == 0 {
 			io.write_string(w, "<p>This section is empty.</p>\n")
 		} else {
@@ -933,11 +953,11 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		name := str(e.name)
 		path := pkg_to_path[pkg]
 		filename := slashpath.base(str(files[e.pos.file].name))
-		fmt.wprintf(w, "<h4 id=\"{0:s}\"><span><a class=\"documentation-id-link\" href=\"#{0:s}\">{0:s}", name)
+		fmt.wprintf(w, "<h4 id=\"{0:s}\"><span><a class=\"doc-id-link\" href=\"#{0:s}\">{0:s}", name)
 		fmt.wprintf(w, "<span class=\"a-hidden\">&nbsp;¶</span></a></span>")
 		if e.pos.file != 0 && e.pos.line > 0 {
 			src_url := fmt.tprintf("%s/%s/%s#L%d", GITHUB_CORE_URL, path, filename, e.pos.line)
-			fmt.wprintf(w, "<div class=\"documentation-source\"><a href=\"{0:s}\"><em>Source</em></a></div>", src_url)
+			fmt.wprintf(w, "<div class=\"doc-source\"><a href=\"{0:s}\"><em>Source</em></a></div>", src_url)
 		}
 		fmt.wprintf(w, "</h4>\n")
 
@@ -945,7 +965,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		case .Invalid, .Import_Name, .Library_Name:
 			// ignore
 		case .Constant:
-			fmt.wprint(w, "<pre>")
+			fmt.wprint(w, `<pre class="doc-code">`)
 			the_type := types[e.type]
 
 			init_string := str(e.init_string)
@@ -973,7 +993,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			io.write_string(w, init_string)
 			fmt.wprintln(w, "</pre>")
 		case .Variable:
-			fmt.wprint(w, "<pre>")
+			fmt.wprint(w, `<pre class="doc-code">`)
 			write_attributes(w, e)
 			fmt.wprintf(w, "%s: ", name)
 			write_type(writer, types[e.type], {.Allow_Indent})
@@ -985,7 +1005,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintln(w, "</pre>")
 
 		case .Type_Name:
-			fmt.wprint(w, "<pre>")
+			fmt.wprint(w, `<pre class="doc-code">`)
 			fmt.wprintf(w, "%s :: ", name)
 			the_type := types[e.type]
 			type_to_print := the_type
@@ -1004,14 +1024,14 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			write_type(writer, type_to_print, {.Allow_Indent})
 			fmt.wprintln(w, "</pre>")
 		case .Procedure:
-			fmt.wprint(w, "<pre>")
+			fmt.wprint(w, `<pre class="doc-code">`)
 			fmt.wprintf(w, "%s :: ", name)
 			write_type(writer, types[e.type], nil)
 			write_where_clauses(w, array(e.where_clauses))
 			fmt.wprint(w, " {…}")
 			fmt.wprintln(w, "</pre>")
 		case .Proc_Group:
-			fmt.wprint(w, "<pre>")
+			fmt.wprint(w, `<pre class="doc-code">`)
 			fmt.wprintf(w, "%s :: proc{{\n", name)
 			for entity_index in array(e.grouped_entities) {
 				this_proc := &entities[entity_index]
@@ -1035,7 +1055,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		write_docs(w, pkg, strings.trim_space(str(e.docs)))
 	}
 	write_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
-		fmt.wprintf(w, "<h3>%s</h3>\n", title)
+		fmt.wprintf(w, "<h3 id=\"pkg-{0:s}\">{0:s}</h3>\n", title)
 		fmt.wprintln(w, `<section class="documentation">`)
 		if len(entities) == 0 {
 			io.write_string(w, "<p>This section is empty.</p>\n")
@@ -1054,7 +1074,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	write_entities(w, "Constants",        pkg_consts[:])
 
 
-	fmt.wprintln(w, "<h3>Source Files</h3>")
+	fmt.wprintln(w, `<h3 id="pkg-source-files">Source Files</h3>`)
 	fmt.wprintln(w, "<ul>")
 	any_hidden := false
 	source_file_loop: for file_index in array(pkg.files) {
@@ -1087,4 +1107,38 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	}
 	fmt.wprintln(w, "</ul>")
 
+
+	fmt.wprintln(w, `</article>`)
+	{
+		write_link :: proc(w: io.Writer, id, text: string) {
+			fmt.wprintf(w, `<li><a href="#%s">%s</a>`, id, text)
+		}
+
+		write_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
+			fmt.wprintf(w, `<li><a href="#pkg-{0:s}">{0:s}</a>`, name)
+			fmt.wprintln(w, `<ul>`)
+			for e in entities {
+				name := str(e.name)
+				fmt.wprintf(w, "<li><a href=\"#{0:s}\">{0:s}</a></li>\n", name)
+			}
+			fmt.wprintln(w, "</ul>")
+			fmt.wprintln(w, "</li>")
+		}
+
+
+		fmt.wprintln(w, `<div class="col-lg-2 odin-toc-border navbar-light"><div class="sticky-top odin-below-navbar py-3">`)
+		fmt.wprintln(w, `<nav id="TableOfContents">`)
+		fmt.wprintln(w, `<ul>`)
+		write_link(w, "pkg-overview", "Overview")
+		write_index(w, "Procedures",       pkg_procs[:])
+		write_index(w, "Procedure Groups", pkg_proc_groups[:])
+		write_index(w, "Types",            pkg_types[:])
+		write_index(w, "Variables",        pkg_vars[:])
+		write_index(w, "Constants",        pkg_consts[:])
+		write_link(w, "pkg-source-files", "Source Files")
+		fmt.wprintln(w, `</ul>`)
+		fmt.wprintln(w, `</nav>`)
+		fmt.wprintln(w, `</div></div>`)
+	}
+
 }
\ No newline at end of file
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index c83a046a8..1972e99e1 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -1,26 +1,18 @@
-html {
-	font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";
-}
+/* doc directories */
 
-.container {
-	max-width: 60em;
-	margin: 0 auto;
-	padding-left: 0.01em 1em;
-}
-
-table.documentation-directory {
+table.doc-directory {
 	/*border: 1px solid #ccc!important;*/
 	table-layout: fixed;
 	border-collapse: collapse;
 }
 
-.documentation-directory tr {
+.doc-directory tr {
 	padding-left: 1em!important;
 	border-top: 1px solid #ccc!important;
 	border-bottom: 1px solid #ccc!important;
 }
 
-.documentation-directory td {
+.doc-directory td {
 	padding: 0.25em 0.5em;
 }
 .directory-child td {
@@ -32,59 +24,62 @@ table.documentation-directory {
 	left: -1.5em!important;
 	padding-right: 0;
 }
-.pkg-line-doc {
-	color: #444;
-}
 
-.documentation-directory tr[aria-controls]:hover {
+.doc-directory tr[aria-controls]:hover {
 	background-color: #eee;
 }
 
-.documentation-directory tr[aria-expanded=true] td.pkg-name:before {
+.doc-directory tr[aria-expanded=true] td.pkg-name:before {
 	content: "\2193";
 }
-.documentation-directory tr[aria-expanded=false] td.pkg-name:before {
+.doc-directory tr[aria-expanded=false] td.pkg-name:before {
 	content: "\2192"!important;
 }
 
-.documentation-directory tr[aria-hidden=true] {
+.doc-directory tr[aria-hidden=true] {
 	display: none;
 }
 
-pre {
+
+/* doc page */
+
+pre.doc-code {
 	white-space: pre-wrap;
 	word-break: keep-all;
 	word-wrap: break-word;
 	tab-size: 8;
-	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
 	background-color: #f8f8f8;
 	color: #202224;
 	border: 1px solid #c6c8ca;
 	border-radius: 0.25rem;
 	padding: 0.625rem;
 }
-
-pre a {
+pre.doc-code a {
 	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
 	text-decoration: none;
 	/*font-weight: bold;*/
 	color: #00bfd5;
 }
 
-.documentation pre a.code-procedure {
+pre.doc-code a.code-procedure {
 	color: #079300;
 }
 
-.documentation-source {
+.pkg-line-doc {
+	color: #444;
+}
+
+
+.doc-source {
 	display: inline;
 	float: right;
 }
 
-.documentation-source a {
+.doc-source a {
 	text-decoration: none;
 	color: #666666;
 }
-.documentation-source a:hover {
+.doc-source a:hover {
 	text-decoration: underline;
 }
 
@@ -95,42 +90,6 @@ a:hover > .a-hidden {
 	opacity: 100;
 }
 
-ul.documentation-breadcrumb {
-	list-style: none;
-}
-
-ul.documentation-breadcrumb li {
-	display: inline;
-}
-
-ul.documentation-breadcrumb li+li:before {
-	padding: 0.2rem;
-	color: black;
-	content:  "/\00a0";
-}
-
-.code-inline {
-	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
-	background-color: #f8f8f8;
-	color: #202224;
-	border: 1px solid #c6c8ca;
-	border-radius: 0.25rem;
-	padding: 0.125rem;
-}
-
-.documentation-directory {
-	width:  100%;
-}
-
-.documentation-directory tr {
-	/*background-color: #999;*/
-}
-
-
-.documentation-directory tr[aria-controls] {
-	cursor: pointer;
-}
-
-.documentation-directory tr.hidden {
-	display: none;
+.documentation h4 {
+	font-size: calc(1.1rem + .2vw);
 }
\ No newline at end of file

From 6bdb210ad8f827c93f0a903c8cdbea73555409ec Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 13:34:54 +0000
Subject: [PATCH 15/37] More improvements to the styling

---
 tools/odin-html-docs/odin_html_docs_main.odin | 72 ++++++++++---------
 tools/odin-html-docs/style.css                |  3 +-
 2 files changed, 41 insertions(+), 34 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index a6b5f428e..a2d516812 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -818,56 +818,60 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 }
 
 write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
-
-
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
 
+	fmt.wprintln(w, `<article class="col-lg-9 p-4">`)
+
 	{ // breadcrumbs
-		fmt.wprintln(w, `<nav class="col-lg-2 odin-side-bar-border navbar-light">`)
-		fmt.wprintln(w, `<div class="sticky-top odin-below-navbar py-3">`)
-		{
-			dirs := strings.split(path, "/")
-			io.write_string(w, "<ul class=\"nav nav-pills d-flex flex-column\">\n")
-			io.write_string(w, `<li class="nav-item"><a class="nav-link" href="/core">core</a></li>`)
-			for dir, i in dirs {
-				url := strings.join(dirs[:i+1], "/")
-				short_path := strings.join(dirs[1:i+1], "/")
+		fmt.wprintln(w, `<div class="row">`)
+		defer fmt.wprintln(w, `</div>`)
 
-				io.write_string(w, `<li class="nav-item">`)
-				a_class := "nav-link"
-				if i+1 == len(dirs) {
-					a_class = "nav-link active"
-				}
+		fmt.wprintln(w, `<nav aria-label="breadcrumb">`)
+		defer fmt.wprintln(w, `</nav>`)
+		io.write_string(w, "<ol class=\"breadcrumb\">\n")
+		defer io.write_string(w, "</ol>\n")
 
-				if i == 0 || short_path in pkgs_to_use {
-					fmt.wprintf(w, `<a class="%s" href="/core/%s">%s</a></li>` + "\n", a_class, url, dir)
-				} else {
-					fmt.wprintf(w, "%s</li>\n", dir)
-				}
+		io.write_string(w, `<li class="breadcrumb-item"><a class="breadcrumb-link" href="/core">core</a></li>`)
+
+		dirs := strings.split(path, "/")
+		for dir, i in dirs {
+			url := strings.join(dirs[:i+1], "/")
+			short_path := strings.join(dirs[1:i+1], "/")
+
+			a_class := "breadcrumb-link"
+			is_curr := i+1 == len(dirs)
+			if is_curr {
+				io.write_string(w, `<li class="breadcrumb-item active" aria-current="page">`)
+			} else {
+				io.write_string(w, `<li class="breadcrumb-item">`)
 			}
-			io.write_string(w, "</ul>\n")
-		}
 
-		fmt.wprintln(w, `</div>`)
-		fmt.wprintln(w, `</nav>`)
+			if !is_curr && short_path in pkgs_to_use {
+				fmt.wprintf(w, `<a href="/core/%s">%s</a>`, url, dir)
+			} else {
+				io.write_string(w, dir)
+			}
+			io.write_string(w, "</li>\n")
+		}
 	}
 
-	fmt.wprintln(w, `<article class="col-lg-8 p-4">`)
 
 	fmt.wprintf(w, "<h1>package core:%s</h1>\n", path)
 	fmt.wprintln(w, "<h2>Documentation</h2>")
-	docs := strings.trim_space(str(pkg.docs))
-	if docs != "" {
+	overview_docs := strings.trim_space(str(pkg.docs))
+	if overview_docs != "" {
 		fmt.wprintln(w, "<h3>Overview</h3>")
 		fmt.wprintln(w, "<div id=\"pkg-overview\">")
 		defer fmt.wprintln(w, "</div>")
 
-		write_docs(w, pkg, docs)
+		write_docs(w, pkg, overview_docs)
 	}
 
-	fmt.wprintln(w, "<h3>Index</h3>")
-	fmt.wprintln(w, `<section class="doc-index">`)
+	fmt.wprintln(w, `<h3>Index</h3>`)
+	fmt.wprintln(w, `<section class="doc-index" id="pkg-index">`)
+	// fmt.wprintln(w, `<a class="btn btn-primary" data-bs-toggle="collapse" href="#pkg-index" role="button" aria-expanded="true" aria-controls="pkg-index"><h3>Index</h3></a>`)
+	// fmt.wprintln(w, `<section class="doc-index collapse" id="pkg-index">`)
 	pkg_procs:       [dynamic]^doc.Entity
 	pkg_proc_groups: [dynamic]^doc.Entity
 	pkg_types:       [dynamic]^doc.Entity
@@ -1126,10 +1130,12 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		}
 
 
-		fmt.wprintln(w, `<div class="col-lg-2 odin-toc-border navbar-light"><div class="sticky-top odin-below-navbar py-3">`)
+		fmt.wprintln(w, `<div class="col-lg-3 odin-toc-border navbar-light"><div class="sticky-top odin-below-navbar py-3">`)
 		fmt.wprintln(w, `<nav id="TableOfContents">`)
 		fmt.wprintln(w, `<ul>`)
-		write_link(w, "pkg-overview", "Overview")
+		if overview_docs != "" {
+			write_link(w, "pkg-overview", "Overview")
+		}
 		write_index(w, "Procedures",       pkg_procs[:])
 		write_index(w, "Procedure Groups", pkg_proc_groups[:])
 		write_index(w, "Types",            pkg_types[:])
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index 1972e99e1..edb94932f 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -1,6 +1,6 @@
 /* doc directories */
 
-table.doc-directory {
+table.`directory {
 	/*border: 1px solid #ccc!important;*/
 	table-layout: fixed;
 	border-collapse: collapse;
@@ -78,6 +78,7 @@ pre.doc-code a.code-procedure {
 .doc-source a {
 	text-decoration: none;
 	color: #666666;
+	font-size: 0.75em;
 }
 .doc-source a:hover {
 	text-decoration: underline;

From 28a816ef25476086800a294202aad7c1a1bfc0f0 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 14:57:27 +0000
Subject: [PATCH 16/37] Allow for entity grouping in structs and procedure
 signatures with the Odin doc-format

---
 core/odin/doc-format/doc_format.odin          |   6 +-
 src/check_type.cpp                            |  13 ++
 src/docs_format.cpp                           |   3 +-
 src/docs_writer.cpp                           |  20 ++-
 src/entity.cpp                                |   2 +
 tools/odin-html-docs/odin_html_docs_main.odin | 121 ++++++++++--------
 tools/odin-html-docs/style.css                |  13 +-
 7 files changed, 119 insertions(+), 59 deletions(-)

diff --git a/core/odin/doc-format/doc_format.odin b/core/odin/doc-format/doc_format.odin
index 83cd89ca2..5e869ff73 100644
--- a/core/odin/doc-format/doc_format.odin
+++ b/core/odin/doc-format/doc_format.odin
@@ -11,7 +11,7 @@ String :: distinct Array(byte)
 
 Version_Type_Major :: 0
 Version_Type_Minor :: 2
-Version_Type_Patch :: 2
+Version_Type_Patch :: 3
 
 Version_Type :: struct {
 	major, minor, patch: u8,
@@ -122,6 +122,10 @@ Entity :: struct {
 	_:                u32le, // reserved for init
 	comment:          String,
 	docs:             String,
+	// May be used by (Struct fields and procedure fields):
+	// .Variable
+	// .Constant
+	field_group_index: i32le,
 
 	// May used by:
 	// .Variable
diff --git a/src/check_type.cpp b/src/check_type.cpp
index 5389252b3..a5a757f3e 100644
--- a/src/check_type.cpp
+++ b/src/check_type.cpp
@@ -109,11 +109,14 @@ void check_struct_fields(CheckerContext *ctx, Ast *node, Slice<Entity *> *fields
 	}
 
 	i32 field_src_index = 0;
+	i32 field_group_index = -1;
 	for_array(i, params) {
 		Ast *param = params[i];
 		if (param->kind != Ast_Field) {
 			continue;
 		}
+		field_group_index += 1;
+
 		ast_node(p, Field, param);
 		Ast *type_expr = p->type;
 		Type *type = nullptr;
@@ -152,6 +155,7 @@ void check_struct_fields(CheckerContext *ctx, Ast *node, Slice<Entity *> *fields
 
 			Entity *field = alloc_entity_field(ctx->scope, name_token, type, is_using, field_src_index);
 			add_entity(ctx, ctx->scope, name, field);
+			field->Variable.field_group_index = field_group_index;
 			array_add(&fields_array, field);
 			String tag = p->tag.string;
 			if (tag.len != 0 && !unquote_string(permanent_allocator(), &tag, 0, tag.text[0] == '`')) {
@@ -1366,11 +1370,13 @@ Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_params, bool *is
 	isize variadic_index = -1;
 	bool is_c_vararg = false;
 	auto variables = array_make<Entity *>(permanent_allocator(), 0, variable_count);
+	i32 field_group_index = -1;
 	for_array(i, params) {
 		Ast *param = params[i];
 		if (param->kind != Ast_Field) {
 			continue;
 		}
+		field_group_index += 1;
 		ast_node(p, Field, param);
 		Ast *type_expr = unparen_expr(p->type);
 		Type *type = nullptr;
@@ -1671,9 +1677,11 @@ Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_params, bool *is
 					}
 
 					param = alloc_entity_const_param(scope, name->Ident.token, type, poly_const, is_type_polymorphic(type));
+					param->Constant.field_group_index = field_group_index;
 				} else {
 					param = alloc_entity_param(scope, name->Ident.token, type, is_using, true);
 					param->Variable.param_value = param_value;
+					param->Variable.field_group_index = field_group_index;
 				}
 			}
 			if (p->flags&FieldFlag_no_alias) {
@@ -1767,7 +1775,10 @@ Type *check_get_results(CheckerContext *ctx, Scope *scope, Ast *_results) {
 	}
 
 	auto variables = array_make<Entity *>(permanent_allocator(), 0, variable_count);
+	i32 field_group_index = -1;
 	for_array(i, results) {
+		field_group_index += 1;
+
 		ast_node(field, Field, results[i]);
 		Ast *default_value = unparen_expr(field->default_value);
 		ParameterValue param_value = {};
@@ -1798,6 +1809,7 @@ Type *check_get_results(CheckerContext *ctx, Scope *scope, Ast *_results) {
 			token.string = str_lit("");
 			Entity *param = alloc_entity_param(scope, token, type, false, false);
 			param->Variable.param_value = param_value;
+			param->Variable.field_group_index = -1;
 			array_add(&variables, param);
 		} else {
 			for_array(j, field->names) {
@@ -1821,6 +1833,7 @@ Type *check_get_results(CheckerContext *ctx, Scope *scope, Ast *_results) {
 				Entity *param = alloc_entity_param(scope, token, type, false, false);
 				param->flags |= EntityFlag_Result;
 				param->Variable.param_value = param_value;
+				param->Variable.field_group_index = field_group_index;
 				array_add(&variables, param);
 				add_entity(ctx, scope, name, param);
 				// NOTE(bill): Removes `declared but not used` when using -vet
diff --git a/src/docs_format.cpp b/src/docs_format.cpp
index 5cfac4817..38e7e20c2 100644
--- a/src/docs_format.cpp
+++ b/src/docs_format.cpp
@@ -15,7 +15,7 @@ struct OdinDocVersionType {
 
 #define OdinDocVersionType_Major 0
 #define OdinDocVersionType_Minor 2
-#define OdinDocVersionType_Patch 2
+#define OdinDocVersionType_Patch 3
 
 struct OdinDocHeaderBase {
 	u8                 magic[8];
@@ -185,6 +185,7 @@ struct OdinDocEntity {
 	u32                reserved_for_init;
 	OdinDocString      comment;
 	OdinDocString      docs;
+	i32                field_group_index;
 	OdinDocEntityIndex foreign_library;
 	OdinDocString      link_name;
 	OdinDocArray<OdinDocAttribute> attributes;
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index 762a2afe1..c4a0cd27f 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -512,10 +512,16 @@ OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 		doc_type.entities = odin_doc_add_entity_as_slice(w, type->Named.type_name);
 		break;
 	case Type_Generic:
-		doc_type.kind = OdinDocType_Generic;
-		doc_type.name = odin_doc_write_string(w, type->Generic.entity->token.string);
-		if (type->Generic.specialized) {
-			doc_type.types = odin_doc_type_as_slice(w, type->Generic.specialized);
+		{
+			String name = type->Generic.name;
+			if (type->Generic.entity) {
+				name = type->Generic.entity->token.string;
+			}
+			doc_type.kind = OdinDocType_Generic;
+			doc_type.name = odin_doc_write_string(w, name);
+			if (type->Generic.specialized) {
+				doc_type.types = odin_doc_type_as_slice(w, type->Generic.specialized);
+			}
 		}
 		break;
 	case Type_Pointer:
@@ -810,6 +816,7 @@ OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) {
 
 	OdinDocEntityKind kind = OdinDocEntity_Invalid;
 	u32 flags = 0;
+	i32 field_group_index = -1;
 
 	switch (e->kind) {
 	case Entity_Invalid:     kind = OdinDocEntity_Invalid;     break;
@@ -839,6 +846,10 @@ OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) {
 		if (init_expr == nullptr) {
 			init_expr = e->Variable.init_expr;
 		}
+		field_group_index = e->Variable.field_group_index;
+		break;
+	case Entity_Constant:
+		field_group_index = e->Constant.field_group_index;
 		break;
 	case Entity_Procedure:
 		if (e->Procedure.is_foreign) { flags |= OdinDocEntityFlag_Foreign; }
@@ -883,6 +894,7 @@ OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) {
 	doc_entity.init_string = init_string;
 	doc_entity.comment = odin_doc_comment_group_string(w, comment);
 	doc_entity.docs = odin_doc_comment_group_string(w, docs);
+	doc_entity.field_group_index = field_group_index;
 	doc_entity.foreign_library = 0; // Set later
 	doc_entity.link_name = odin_doc_write_string(w, link_name);
 	if (e->decl_info != nullptr) {
diff --git a/src/entity.cpp b/src/entity.cpp
index b39ffc63a..05ee9a33e 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -160,10 +160,12 @@ struct Entity {
 			ExactValue value;
 			ParameterValue param_value;
 			u32 flags;
+			i32 field_group_index;
 		} Constant;
 		struct {
 			Ast *init_expr; // only used for some variables within procedure bodies
 			i32  field_index;
+			i32  field_group_index;
 
 			ParameterValue param_value;
 
diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index a2d516812..e196aa236 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -10,6 +10,7 @@ import "core:sort"
 import "core:slice"
 
 GITHUB_CORE_URL :: "https://github.com/odin-lang/Odin/tree/master/core"
+BASE_CORE_URL :: "/core"
 
 header:   ^doc.Header
 files:    []doc.File
@@ -96,7 +97,7 @@ write_html_footer :: proc(w: io.Writer, include_directory_js: bool) {
 
 	io.write(w, #load("footer.txt.html"))
 
-	if include_directory_js {
+	if false && include_directory_js {
 		io.write_string(w, `
 <script type="text/javascript">
 (function (win, doc) {
@@ -319,7 +320,7 @@ write_core_directory :: proc(w: io.Writer) {
 		}
 
 		if dir.pkg != nil {
-			fmt.wprintf(w, `<a href="/core/%s">%s</a>`, dir.path, dir.name)
+			fmt.wprintf(w, `<a href="%s/%s">%s</a>`, BASE_CORE_URL, dir.path, dir.name)
 		} else {
 			fmt.wprintf(w, "%s", dir.name)
 		}
@@ -338,7 +339,7 @@ write_core_directory :: proc(w: io.Writer) {
 		for child := dir.first_child; child != nil; child = child.next {
 			assert(child.pkg != nil)
 			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg directory-child"><td class="pkg-line pkg-name">`, str(child.pkg.name))
-			fmt.wprintf(w, `<a href="/core/%s/">%s</a>`, child.path, child.name)
+			fmt.wprintf(w, `<a href="%s/%s/">%s</a>`, BASE_CORE_URL, child.path, child.name)
 			io.write_string(w, `</td>`)
 
 			line_doc, _, _ := strings.partition(str(child.pkg.docs), "\n")
@@ -392,7 +393,7 @@ Type_Writer :: struct {
 }
 
 write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type_Flags) {
-	write_param_entity :: proc(using writer: ^Type_Writer, e: ^doc.Entity, flags: Write_Type_Flags, name_width := 0) {
+	write_param_entity :: proc(using writer: ^Type_Writer, e, next_entity: ^doc.Entity, flags: Write_Type_Flags, name_width := 0) {
 		name := str(e.name)
 
 		write_padding :: proc(w: io.Writer, name: string, name_width: int) {
@@ -414,13 +415,13 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			assert(name != "")
 			io.write_string(w, name)
 			io.write_string(w, " := ")
-			io.write_string(w, `<a href="/core/runtime/#Source_Code_Location">`)
+			fmt.wprintf(w, `<a href="%s/runtime/#Source_Code_Location">`, BASE_CORE_URL)
 			io.write_string(w, init_string)
 			io.write_string(w, `</a>`)
 		case strings.has_prefix(init_string, "context."):
 			io.write_string(w, name)
 			io.write_string(w, " := ")
-			io.write_string(w, `<a href="/core/runtime/#Context">`)
+			fmt.wprintf(w, `<a href="%s/runtime/#Context">`, BASE_CORE_URL)
 			io.write_string(w, init_string)
 			io.write_string(w, `</a>`)
 		case:
@@ -435,6 +436,12 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 				assert(name != "")
 				io.write_byte(w, '$')
 				io.write_string(w, name)
+				if name != "" && init_string == "" && next_entity != nil && e.field_group_index >= 0 {
+					if e.field_group_index == next_entity.field_group_index && e.type == next_entity.type {
+						return
+					}
+				}
+
 				generic_scope[name] = true
 				if !is_type_untyped(the_type) {
 					io.write_string(w, ": ")
@@ -449,6 +456,13 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 				return
 
 			case .Variable:
+				if name != "" && init_string == "" && next_entity != nil && e.field_group_index >= 0 {
+					if e.field_group_index == next_entity.field_group_index && e.type == next_entity.type {
+						io.write_string(w, name)
+						return
+					}
+				}
+
 				if name != "" {
 					io.write_string(w, name)
 					io.write_string(w, ": ")
@@ -530,10 +544,10 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			fmt.wprintf(w, `%s.`, str(pkgs[tn_pkg].name))
 		}
 		if n := strings.contains_rune(name, '('); n >= 0 {
-			fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name[:n])
+			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name[:n], BASE_CORE_URL)
 			io.write_string(w, name[n:])
 		} else {
-			fmt.wprintf(w, `<a class="code-typename" href="/core/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name)
+			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name, BASE_CORE_URL)
 		}
 	case .Generic:
 		name := str(type.name)
@@ -590,10 +604,14 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			indent += 1
 			name_width := calc_name_width(type_entites)
 
-			for entity_index in type_entites {
+			for entity_index, i in type_entites {
 				e := &entities[entity_index]
+				next_entity: ^doc.Entity = nil
+				if i+1 < len(type_entites) {
+					next_entity = &entities[type_entites[i+1]]
+				}
 				do_indent(writer, flags)
-				write_param_entity(writer, e, flags, name_width)
+				write_param_entity(writer, e, next_entity, flags, name_width)
 				io.write_byte(w, ',')
 				do_newline(writer, flags)
 			}
@@ -667,7 +685,12 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			if i > 0 {
 				io.write_string(w, ", ")
 			}
-			write_param_entity(writer, &entities[entity_index], flags)
+			e := &entities[entity_index]
+			next_entity: ^doc.Entity = nil
+			if i+1 < len(type_entites) {
+				next_entity = &entities[type_entites[i+1]]
+			}
+			write_param_entity(writer, e, next_entity, flags)
 		}
 		if require_parens { io.write_byte(w, ')') }
 
@@ -821,7 +844,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
 
-	fmt.wprintln(w, `<article class="col-lg-9 p-4">`)
+	fmt.wprintln(w, `<article class="col-lg-9 p-4 documentation">`)
 
 	{ // breadcrumbs
 		fmt.wprintln(w, `<div class="row">`)
@@ -832,7 +855,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		io.write_string(w, "<ol class=\"breadcrumb\">\n")
 		defer io.write_string(w, "</ol>\n")
 
-		io.write_string(w, `<li class="breadcrumb-item"><a class="breadcrumb-link" href="/core">core</a></li>`)
+		fmt.wprintf(w, `<li class="breadcrumb-item"><a class="breadcrumb-link" href="%s">core</a></li>`, BASE_CORE_URL)
 
 		dirs := strings.split(path, "/")
 		for dir, i in dirs {
@@ -848,7 +871,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			}
 
 			if !is_curr && short_path in pkgs_to_use {
-				fmt.wprintf(w, `<a href="/core/%s">%s</a>`, url, dir)
+				fmt.wprintf(w, `<a href="%s/%s">%s</a>`, BASE_CORE_URL, url, dir)
 			} else {
 				io.write_string(w, dir)
 			}
@@ -858,19 +881,18 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 
 
 	fmt.wprintf(w, "<h1>package core:%s</h1>\n", path)
-	fmt.wprintln(w, "<h2>Documentation</h2>")
 	overview_docs := strings.trim_space(str(pkg.docs))
 	if overview_docs != "" {
-		fmt.wprintln(w, "<h3>Overview</h3>")
+		fmt.wprintln(w, "<h2>Overview</h2>")
 		fmt.wprintln(w, "<div id=\"pkg-overview\">")
 		defer fmt.wprintln(w, "</div>")
 
 		write_docs(w, pkg, overview_docs)
 	}
 
-	fmt.wprintln(w, `<h3>Index</h3>`)
+	fmt.wprintln(w, `<h2>Index</h2>`)
 	fmt.wprintln(w, `<section class="doc-index" id="pkg-index">`)
-	// fmt.wprintln(w, `<a class="btn btn-primary" data-bs-toggle="collapse" href="#pkg-index" role="button" aria-expanded="true" aria-controls="pkg-index"><h3>Index</h3></a>`)
+	// fmt.wprintln(w, `<a class="btn btn-primary" data-bs-toggle="collapse" href="#pkg-index" role="button" aria-expanded="true" aria-controls="pkg-index"><h2>Index</h2></a>`)
 	// fmt.wprintln(w, `<section class="doc-index collapse" id="pkg-index">`)
 	pkg_procs:       [dynamic]^doc.Entity
 	pkg_proc_groups: [dynamic]^doc.Entity
@@ -906,7 +928,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	slice.sort_by_key(pkg_consts[:],      entity_key)
 
 	write_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
-		fmt.wprintf(w, "<h4>%s</h4>\n", name)
+		fmt.wprintf(w, "<h3>%s</h3>\n", name)
 		fmt.wprintln(w, `<section class="doc-index">`)
 		if len(entities) == 0 {
 			io.write_string(w, "<p>This section is empty.</p>\n")
@@ -921,12 +943,18 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		fmt.wprintln(w, "</section>")
 	}
 
+	entity_ordering := [?]struct{name: string, entities: []^doc.Entity} {
+		{"Types",            pkg_types[:]},
+		{"Constants",        pkg_consts[:]},
+		{"Variables",        pkg_vars[:]},
+		{"Procedures",       pkg_procs[:]},
+		{"Procedure Groups", pkg_proc_groups[:]},
+	}
 
-	write_index(w, "Procedures",       pkg_procs[:])
-	write_index(w, "Procedure Groups", pkg_proc_groups[:])
-	write_index(w, "Types",            pkg_types[:])
-	write_index(w, "Variables",        pkg_vars[:])
-	write_index(w, "Constants",        pkg_consts[:])
+
+	for eo in entity_ordering {
+		write_index(w, eo.name, eo.entities)
+	}
 
 	fmt.wprintln(w, "</section>")
 
@@ -957,13 +985,13 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		name := str(e.name)
 		path := pkg_to_path[pkg]
 		filename := slashpath.base(str(files[e.pos.file].name))
-		fmt.wprintf(w, "<h4 id=\"{0:s}\"><span><a class=\"doc-id-link\" href=\"#{0:s}\">{0:s}", name)
+		fmt.wprintf(w, "<h3 id=\"{0:s}\"><span><a class=\"doc-id-link\" href=\"#{0:s}\">{0:s}", name)
 		fmt.wprintf(w, "<span class=\"a-hidden\">&nbsp;¶</span></a></span>")
 		if e.pos.file != 0 && e.pos.line > 0 {
 			src_url := fmt.tprintf("%s/%s/%s#L%d", GITHUB_CORE_URL, path, filename, e.pos.line)
 			fmt.wprintf(w, "<div class=\"doc-source\"><a href=\"{0:s}\"><em>Source</em></a></div>", src_url)
 		}
-		fmt.wprintf(w, "</h4>\n")
+		fmt.wprintf(w, "</h3>\n")
 
 		switch e.kind {
 		case .Invalid, .Import_Name, .Library_Name:
@@ -1045,7 +1073,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 					fmt.wprintf(w, "%s.", str(pkgs[this_pkg].name))
 				}
 				name := str(this_proc.name)
-				fmt.wprintf(w, `<a class="code-procedure" href="/core/{0:s}/#{1:s}">`, pkg_to_path[&pkgs[this_pkg]], name)
+				fmt.wprintf(w, `<a class="code-procedure" href="{2:s}/{0:s}/#{1:s}">`, pkg_to_path[&pkgs[this_pkg]], name, BASE_CORE_URL)
 				io.write_string(w, name)
 				io.write_string(w, `</a>`)
 				io.write_byte(w, ',')
@@ -1059,7 +1087,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		write_docs(w, pkg, strings.trim_space(str(e.docs)))
 	}
 	write_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
-		fmt.wprintf(w, "<h3 id=\"pkg-{0:s}\">{0:s}</h3>\n", title)
+		fmt.wprintf(w, "<h2 id=\"pkg-{0:s}\">{0:s}</h2>\n", title)
 		fmt.wprintln(w, `<section class="documentation">`)
 		if len(entities) == 0 {
 			io.write_string(w, "<p>This section is empty.</p>\n")
@@ -1071,14 +1099,11 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		fmt.wprintln(w, "</section>")
 	}
 
-	write_entities(w, "Procedures",       pkg_procs[:])
-	write_entities(w, "Procedure Groups", pkg_proc_groups[:])
-	write_entities(w, "Types",            pkg_types[:])
-	write_entities(w, "Variables",        pkg_vars[:])
-	write_entities(w, "Constants",        pkg_consts[:])
+	for eo in entity_ordering {
+		write_entities(w, eo.name, eo.entities)
+	}
 
-
-	fmt.wprintln(w, `<h3 id="pkg-source-files">Source Files</h3>`)
+	fmt.wprintln(w, `<h2 id="pkg-source-files">Source Files</h2>`)
 	fmt.wprintln(w, "<ul>")
 	any_hidden := false
 	source_file_loop: for file_index in array(pkg.files) {
@@ -1118,29 +1143,21 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintf(w, `<li><a href="#%s">%s</a>`, id, text)
 		}
 
-		write_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
-			fmt.wprintf(w, `<li><a href="#pkg-{0:s}">{0:s}</a>`, name)
-			fmt.wprintln(w, `<ul>`)
-			for e in entities {
-				name := str(e.name)
-				fmt.wprintf(w, "<li><a href=\"#{0:s}\">{0:s}</a></li>\n", name)
-			}
-			fmt.wprintln(w, "</ul>")
-			fmt.wprintln(w, "</li>")
-		}
-
-
 		fmt.wprintln(w, `<div class="col-lg-3 odin-toc-border navbar-light"><div class="sticky-top odin-below-navbar py-3">`)
 		fmt.wprintln(w, `<nav id="TableOfContents">`)
 		fmt.wprintln(w, `<ul>`)
 		if overview_docs != "" {
 			write_link(w, "pkg-overview", "Overview")
 		}
-		write_index(w, "Procedures",       pkg_procs[:])
-		write_index(w, "Procedure Groups", pkg_proc_groups[:])
-		write_index(w, "Types",            pkg_types[:])
-		write_index(w, "Variables",        pkg_vars[:])
-		write_index(w, "Constants",        pkg_consts[:])
+		for eo in entity_ordering do if len(eo.entities) != 0 {
+			fmt.wprintf(w, `<li><a href="#pkg-{0:s}">{0:s}</a>`, eo.name)
+			fmt.wprintln(w, `<ul>`)
+			for e in eo.entities {
+				fmt.wprintf(w, "<li><a href=\"#{0:s}\">{0:s}</a></li>\n", str(e.name))
+			}
+			fmt.wprintln(w, "</ul>")
+			fmt.wprintln(w, "</li>")
+		}
 		write_link(w, "pkg-source-files", "Source Files")
 		fmt.wprintln(w, `</ul>`)
 		fmt.wprintln(w, `</nav>`)
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index edb94932f..cf3782c5d 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -91,6 +91,17 @@ a:hover > .a-hidden {
 	opacity: 100;
 }
 
-.documentation h4 {
+article.documentation h2 {
+	border-bottom: 1px dashed #c6c8ca;
+	padding-bottom: 0.5rem;
+}
+section.documentation h3 {
 	font-size: calc(1.1rem + .2vw);
+}
+
+
+
+.doc-index h3 {
+	border-bottom: 1px solid #c6c8ca;
+	padding-bottom: 0.25rem;
 }
\ No newline at end of file

From 5ff82fc1132a05d76592e8e21db98913cd498f64 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 15:11:42 +0000
Subject: [PATCH 17/37] Correct tuple name checking for doc writing

---
 src/docs_writer.cpp | 2 +-
 src/exact_value.cpp | 2 +-
 src/types.cpp       | 9 +++++++--
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index c4a0cd27f..f1f110a57 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -483,7 +483,7 @@ OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 	for_array(i, w->type_cache.entries) {
 		// NOTE(bill): THIS IS SLOW
 		Type *other = w->type_cache.entries[i].key;
-		if (are_types_identical(type, other)) {
+		if (are_types_identical(type, other, true)) {
 			OdinDocTypeIndex index = w->type_cache.entries[i].value;
 			map_set(&w->type_cache, type, index);
 			return index;
diff --git a/src/exact_value.cpp b/src/exact_value.cpp
index fd90278e5..e979e3d45 100644
--- a/src/exact_value.cpp
+++ b/src/exact_value.cpp
@@ -9,7 +9,7 @@ struct Ast;
 struct HashKey;
 struct Type;
 struct Entity;
-bool are_types_identical(Type *x, Type *y);
+bool are_types_identical(Type *x, Type *y, bool check_tuple_names=false);
 
 struct Complex128 {
 	f64 real, imag;
diff --git a/src/types.cpp b/src/types.cpp
index 6162a5aa8..98dc30703 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -694,7 +694,7 @@ gbString type_to_string       (Type *type);
 i64      type_size_of_internal(Type *t, TypePath *path);
 void     init_map_internal_types(Type *type);
 Type *   bit_set_to_int(Type *t);
-bool are_types_identical(Type *x, Type *y);
+bool are_types_identical(Type *x, Type *y, bool check_tuple_names/*=false*/);
 
 bool is_type_pointer(Type *t);
 bool is_type_proc(Type *t);
@@ -2338,7 +2338,7 @@ Type *strip_type_aliasing(Type *x) {
 	return x;
 }
 
-bool are_types_identical(Type *x, Type *y) {
+bool are_types_identical(Type *x, Type *y, bool check_tuple_names) {
 	if (x == y) {
 		return true;
 	}
@@ -2487,6 +2487,11 @@ bool are_types_identical(Type *x, Type *y) {
 					if (xe->kind != ye->kind || !are_types_identical(xe->type, ye->type)) {
 						return false;
 					}
+					if (check_tuple_names) {
+						if (xe->token.string != ye->token.string) {
+							return false;
+						}
+					}
 					if (xe->kind == Entity_Constant && !compare_exact_values(Token_CmpEq, xe->Constant.value, ye->Constant.value)) {
 						// NOTE(bill): This is needed for polymorphic procedures
 						return false;

From ecdaac9921fbf351bfddaf920553855ae6a5d58f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 15:14:15 +0000
Subject: [PATCH 18/37] Unify `are_types_identical_unique_tuples`

---
 src/checker.cpp     |  4 ++--
 src/docs_writer.cpp |  2 +-
 src/exact_value.cpp |  2 +-
 src/types.cpp       | 14 ++++++++++++--
 4 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/checker.cpp b/src/checker.cpp
index 44dc90c67..63a697072 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1253,7 +1253,7 @@ isize type_info_index(CheckerInfo *info, Type *type, bool error_on_failure) {
 		// TODO(bill): This is O(n) and can be very slow
 		for_array(i, info->type_info_map.entries){
 			auto *e = &info->type_info_map.entries[i];
-			if (are_types_identical(e->key, type)) {
+			if (are_types_identical_unique_tuples(e->key, type)) {
 				entry_index = e->value;
 				// NOTE(bill): Add it to the search map
 				map_set(&info->type_info_map, type, entry_index);
@@ -1601,7 +1601,7 @@ void add_type_info_type_internal(CheckerContext *c, Type *t) {
 	isize ti_index = -1;
 	for_array(i, c->info->type_info_map.entries) {
 		auto *e = &c->info->type_info_map.entries[i];
-		if (are_types_identical(t, e->key)) {
+		if (are_types_identical_unique_tuples(t, e->key)) {
 			// Duplicate entry
 			ti_index = e->value;
 			prev = true;
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index f1f110a57..c2d07dc12 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -483,7 +483,7 @@ OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 	for_array(i, w->type_cache.entries) {
 		// NOTE(bill): THIS IS SLOW
 		Type *other = w->type_cache.entries[i].key;
-		if (are_types_identical(type, other, true)) {
+		if (are_types_identical_unique_tuples(type, other)) {
 			OdinDocTypeIndex index = w->type_cache.entries[i].value;
 			map_set(&w->type_cache, type, index);
 			return index;
diff --git a/src/exact_value.cpp b/src/exact_value.cpp
index e979e3d45..fd90278e5 100644
--- a/src/exact_value.cpp
+++ b/src/exact_value.cpp
@@ -9,7 +9,7 @@ struct Ast;
 struct HashKey;
 struct Type;
 struct Entity;
-bool are_types_identical(Type *x, Type *y, bool check_tuple_names=false);
+bool are_types_identical(Type *x, Type *y);
 
 struct Complex128 {
 	f64 real, imag;
diff --git a/src/types.cpp b/src/types.cpp
index 98dc30703..07951196a 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -694,7 +694,7 @@ gbString type_to_string       (Type *type);
 i64      type_size_of_internal(Type *t, TypePath *path);
 void     init_map_internal_types(Type *type);
 Type *   bit_set_to_int(Type *t);
-bool are_types_identical(Type *x, Type *y, bool check_tuple_names/*=false*/);
+bool are_types_identical(Type *x, Type *y);
 
 bool is_type_pointer(Type *t);
 bool is_type_proc(Type *t);
@@ -2338,7 +2338,17 @@ Type *strip_type_aliasing(Type *x) {
 	return x;
 }
 
-bool are_types_identical(Type *x, Type *y, bool check_tuple_names) {
+bool are_types_identical_internal(Type *x, Type *y, bool check_tuple_names);
+
+bool are_types_identical(Type *x, Type *y) {
+	return are_types_identical_internal(x, y, false);
+}
+bool are_types_identical_unique_tuples(Type *x, Type *y) {
+	return are_types_identical_internal(x, y, true);
+}
+
+
+bool are_types_identical_internal(Type *x, Type *y, bool check_tuple_names) {
 	if (x == y) {
 		return true;
 	}

From 07ee23f817ebac33a8b4877bd40d1597734108ad Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 16:28:01 +0000
Subject: [PATCH 19/37] Simplify dir tree generation

---
 tools/odin-html-docs/odin_html_docs_main.odin | 115 +++++++++---------
 1 file changed, 59 insertions(+), 56 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index e196aa236..b9d9f37a6 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -199,7 +199,6 @@ main :: proc() {
 
 			pkgs_to_use[trimmed_path] = pkg
 		}
-		sort.map_entries_by_key(&pkgs_to_use)
 		for path, pkg in pkgs_to_use {
 			pkg_to_path[pkg] = path
 		}
@@ -228,66 +227,70 @@ main :: proc() {
 }
 
 
-write_core_directory :: proc(w: io.Writer) {
-	Node :: struct {
-		dir: string,
-		path: string,
-		name: string,
-		pkg: ^doc.Pkg,
-		next: ^Node,
-		first_child: ^Node,
-	}
-	add_child :: proc(parent: ^Node, child: ^Node) -> ^Node {
-		assert(parent != nil)
-		end := &parent.first_child
-		for end^ != nil {
-			end = &end^.next
-		}
-		child.next = end^
-		end^ = child
-		return child
-	}
+Dir_Node :: struct {
+	dir: string,
+	path: string,
+	name: string,
+	pkg: ^doc.Pkg,
+	children: [dynamic]^Dir_Node,
+}
 
-	root: Node
+generate_directory_tree :: proc() -> (root: ^Dir_Node) {
+	sort_tree :: proc(node: ^Dir_Node) {
+		slice.sort_by_key(node.children[:], proc(node: ^Dir_Node) -> string {return node.name})
+		for child in node.children {
+			sort_tree(child)
+		}
+	}
+	root = new(Dir_Node)
+	root.children = make([dynamic]^Dir_Node)
+	children := make([dynamic]^Dir_Node)
 	for path, pkg in pkgs_to_use {
 		dir, _, inner := strings.partition(path, "/")
-
-		node: ^Node = nil
-		for node = root.first_child; node != nil; node = node.next {
-			if node.dir == dir {
-				break
-			}
-		}
 		if inner == "" {
-			if node == nil {
-				add_child(&root, new_clone(Node{
-					dir  = dir,
-					name = dir,
-					path = path,
-					pkg  = pkg,
-				}))
-			} else {
-				node.dir  = dir
-				node.name = dir
-				node.path = path
-				node.pkg  = pkg
-			}
+			node := new_clone(Dir_Node{
+				dir  = dir,
+				name = dir,
+				path = path,
+				pkg  = pkg,
+			})
+			append(&root.children, node)
 		} else {
-			if node == nil {
-				node = add_child(&root, new_clone(Node{
-					dir  = dir,
-					name = dir,
-				}))
-			}
-			assert(node != nil)
-			child := add_child(node, new_clone(Node{
+			node := new_clone(Dir_Node{
 				dir  = dir,
 				name = inner,
 				path = path,
 				pkg  = pkg,
-			}))
+			})
+			append(&children, node)
 		}
 	}
+	child_loop: for child in children {
+		dir, _, inner := strings.partition(child.path, "/")
+		for node in root.children {
+			if node.dir == dir {
+				append(&node.children, child)
+				continue child_loop
+			}
+		}
+		parent := new_clone(Dir_Node{
+			dir  = dir,
+			name = dir,
+			path = dir,
+			pkg  = nil,
+		})
+		append(&root.children, parent)
+		append(&parent.children, child)
+	}
+
+	sort_tree(root)
+
+	return
+}
+
+write_core_directory :: proc(w: io.Writer) {
+
+	root := generate_directory_tree()
 
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
@@ -304,14 +307,14 @@ write_core_directory :: proc(w: io.Writer) {
 	fmt.wprintln(w, "\t<table class=\"doc-directory mt-4 mb-4\">")
 	fmt.wprintln(w, "\t\t<tbody>")
 
-	for dir := root.first_child; dir != nil; dir = dir.next {
-		if dir.first_child != nil {
+	for dir in root.children {
+		if len(dir.children) != 0 {
 			fmt.wprint(w, `<tr aria-controls="`)
-			for child := dir.first_child; child != nil; child = child.next {
+			for child in dir.children {
 				fmt.wprintf(w, "pkg-%s ", str(child.pkg.name))
 			}
 			fmt.wprint(w, `" class="directory-pkg"><td class="pkg-line pkg-name" data-aria-owns="`)
-			for child := dir.first_child; child != nil; child = child.next {
+			for child in dir.children {
 				fmt.wprintf(w, "pkg-%s ", str(child.pkg.name))
 			}
 			fmt.wprintf(w, `" id="pkg-%s">`, dir.dir)
@@ -336,7 +339,7 @@ write_core_directory :: proc(w: io.Writer) {
 		io.write_string(w, `</td>`)
 		fmt.wprintf(w, "</tr>\n")
 
-		for child := dir.first_child; child != nil; child = child.next {
+		for child in dir.children {
 			assert(child.pkg != nil)
 			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg directory-child"><td class="pkg-line pkg-name">`, str(child.pkg.name))
 			fmt.wprintf(w, `<a href="%s/%s/">%s</a>`, BASE_CORE_URL, child.path, child.name)
@@ -870,7 +873,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 				io.write_string(w, `<li class="breadcrumb-item">`)
 			}
 
-			if !is_curr && short_path in pkgs_to_use {
+			if !is_curr && (short_path in pkgs_to_use) {
 				fmt.wprintf(w, `<a href="%s/%s">%s</a>`, BASE_CORE_URL, url, dir)
 			} else {
 				io.write_string(w, dir)

From b5754b6ed9082bb729ea5d18a926c723e52f377f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 16:35:50 +0000
Subject: [PATCH 20/37] Print examples correctly

---
 core/sync/barrier.odin                        | 73 +++++++++----------
 core/sync/sync2/extended.odin                 | 71 +++++++++---------
 tools/odin-html-docs/odin_html_docs_main.odin | 16 +++-
 3 files changed, 83 insertions(+), 77 deletions(-)

diff --git a/core/sync/barrier.odin b/core/sync/barrier.odin
index 997fde82d..13c870a3b 100644
--- a/core/sync/barrier.odin
+++ b/core/sync/barrier.odin
@@ -1,44 +1,43 @@
 package sync
 
 
-// A barrier enabling multiple threads to synchronize the beginning of some computation
 /*
- * Example:
- *
- * 	package example
- *
- * 	import "core:fmt"
- * 	import "core:sync"
- * 	import "core:thread"
- *
- * 	barrier := &sync.Barrier{};
- *
- * 	main :: proc() {
- * 		fmt.println("Start");
- *
- * 		THREAD_COUNT :: 4;
- * 		threads: [THREAD_COUNT]^thread.Thread;
- *
- * 		sync.barrier_init(barrier, THREAD_COUNT);
- * 		defer sync.barrier_destroy(barrier);
- *
- *
- * 		for _, i in threads {
- * 			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
- * 				// Same messages will be printed together but without any interleaving
- * 				fmt.println("Getting ready!");
- * 				sync.barrier_wait(barrier);
- * 				fmt.println("Off their marks they go!");
- * 			});
- * 		}
- *
- * 		for t in threads {
- * 			thread.destroy(t); // join and free thread
- * 		}
- * 		fmt.println("Finished");
- * 	}
- *
- */
+A barrier enabling multiple threads to synchronize the beginning of some computation
+Example:
+
+	package example
+
+	import "core:fmt"
+	import "core:sync"
+	import "core:thread"
+
+	barrier := &sync.Barrier{};
+
+	main :: proc() {
+		fmt.println("Start");
+
+		THREAD_COUNT :: 4;
+		threads: [THREAD_COUNT]^thread.Thread;
+
+		sync.barrier_init(barrier, THREAD_COUNT);
+		defer sync.barrier_destroy(barrier);
+
+
+		for _, i in threads {
+			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
+				// Same messages will be printed together but without any interleaving
+				fmt.println("Getting ready!");
+				sync.barrier_wait(barrier);
+				fmt.println("Off their marks they go!");
+			});
+		}
+
+		for t in threads {
+			thread.destroy(t); // join and free thread
+		}
+		fmt.println("Finished");
+	}
+*/
 Barrier :: struct {
 	mutex: Blocking_Mutex,
 	cond:  Condition,
diff --git a/core/sync/sync2/extended.odin b/core/sync/sync2/extended.odin
index d6a99fe04..deb48a22d 100644
--- a/core/sync/sync2/extended.odin
+++ b/core/sync/sync2/extended.odin
@@ -67,44 +67,41 @@ wait_group_wait_with_timeout :: proc(wg: ^Wait_Group, duration: time.Duration) -
 
 
 
-// A barrier enabling multiple threads to synchronize the beginning of some computation
 /*
- * Example:
- *
- * 	package example
- *
- * 	import "core:fmt"
- * 	import "core:sync"
- * 	import "core:thread"
- *
- * 	barrier := &sync.Barrier{}
- *
- * 	main :: proc() {
- * 		fmt.println("Start")
- *
- * 		THREAD_COUNT :: 4
- * 		threads: [THREAD_COUNT]^thread.Thread
- *
- * 		sync.barrier_init(barrier, THREAD_COUNT)
- * 		defer sync.barrier_destroy(barrier)
- *
- *
- * 		for _, i in threads {
- * 			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
- * 				// Same messages will be printed together but without any interleaving
- * 				fmt.println("Getting ready!")
- * 				sync.barrier_wait(barrier)
- * 				fmt.println("Off their marks they go!")
- * 			})
- * 		}
- *
- * 		for t in threads {
- * 			thread.destroy(t) // join and free thread
- * 		}
- * 		fmt.println("Finished")
- * 	}
- *
- */
+A barrier enabling multiple threads to synchronize the beginning of some computation
+
+Example:
+	package example
+
+	import "core:fmt"
+	import "core:sync"
+	import "core:thread"
+
+	barrier := &sync.Barrier{}
+
+	main :: proc() {
+		fmt.println("Start")
+
+		THREAD_COUNT :: 4
+		threads: [THREAD_COUNT]^thread.Thread
+
+		sync.barrier_init(barrier, THREAD_COUNT)
+
+		for _, i in threads {
+			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
+				// Same messages will be printed together but without any interleaving
+				fmt.println("Getting ready!")
+				sync.barrier_wait(barrier)
+				fmt.println("Off their marks they go!")
+			})
+		}
+
+		for t in threads {
+			thread.destroy(t) // join and free thread
+		}
+		fmt.println("Finished")
+	}
+*/
 Barrier :: struct {
 	mutex: Mutex,
 	cond:  Cond,
diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index b9d9f37a6..89a82ad77 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -802,21 +802,31 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 	it := docs
 	was_code := true
 	was_paragraph := true
+	prev_line: string
 	for line in strings.split_iterator(&it, "\n") {
+		text := strings.trim_space(line)
+		defer prev_line = line
+
 		if strings.has_prefix(line, "\t") {
 			if !was_code {
 				was_code = true;
-				fmt.wprint(w, `<pre class="doc-code"><code>`)
+				if prev_line == "Example:"  {
+					fmt.wprint(w, `<pre class="doc-code doc-code-example"><code>`)
+				} else {
+					fmt.wprint(w, `<pre class="doc-code"><code>`)
+				}
 			}
 			fmt.wprintf(w, "%s\n", strings.trim_prefix(line, "\t"))
 			continue
 		} else if was_code {
+			if text == "" {
+				continue
+			}
 			was_code = false
 			fmt.wprintln(w, "</code></pre>")
-			continue
 		}
-		text := strings.trim_space(line)
 		if text == "" {
+
 			if was_paragraph {
 				was_paragraph = false
 				fmt.wprintln(w, "</p>")

From 2b918ada4bd640f9b0057f2ae4213fb73cae6ac5 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 19 Jan 2022 17:15:10 +0000
Subject: [PATCH 21/37] Add `.Private` information to doc-format

---
 core/odin/doc-format/doc_format.odin          |  2 +
 core/sync/sync2/primitives.odin               | 50 +++++++++---------
 core/sync/sync2/primitives_atomic.odin        | 51 +++++++++----------
 core/sync/sync2/sema_internal.odin            |  1 +
 core/sync/sync2/sync_util.odin                | 26 +++++-----
 src/docs_format.cpp                           |  2 +
 src/docs_writer.cpp                           |  5 +-
 tools/odin-html-docs/odin_html_docs_main.odin |  5 +-
 8 files changed, 73 insertions(+), 69 deletions(-)

diff --git a/core/odin/doc-format/doc_format.odin b/core/odin/doc-format/doc_format.odin
index 5e869ff73..59eafdc09 100644
--- a/core/odin/doc-format/doc_format.odin
+++ b/core/odin/doc-format/doc_format.odin
@@ -107,6 +107,8 @@ Entity_Flag :: enum u32le {
 
 	Var_Thread_Local = 40,
 	Var_Static       = 41,
+
+	Private = 50,
 }
 
 Entity_Flags :: distinct bit_set[Entity_Flag; u64le]
diff --git a/core/sync/sync2/primitives.odin b/core/sync/sync2/primitives.odin
index d9e013664..6d056d439 100644
--- a/core/sync/sync2/primitives.odin
+++ b/core/sync/sync2/primitives.odin
@@ -29,12 +29,12 @@ mutex_try_lock :: proc(m: ^Mutex) -> bool {
 	return _mutex_try_lock(m)
 }
 
-// Example:
-//
-// if mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=mutex_unlock)
 mutex_guard :: proc(m: ^Mutex) -> bool {
 	mutex_lock(m)
@@ -80,25 +80,24 @@ rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) {
 rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool {
 	return _rw_mutex_try_shared_lock(rw)
 }
-
-// Example:
-//
-// if rw_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if rw_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=rw_mutex_unlock)
 rw_mutex_guard :: proc(m: ^RW_Mutex) -> bool {
 	rw_mutex_lock(m)
 	return true
 }
 
-// Example:
-//
-// if rw_mutex_shared_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if rw_mutex_shared_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=rw_mutex_shared_unlock)
 rw_mutex_shared_guard :: proc(m: ^RW_Mutex) -> bool {
 	rw_mutex_shared_lock(m)
@@ -127,13 +126,12 @@ recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool {
 	return _recursive_mutex_try_lock(m)
 }
 
-
-// Example:
-//
-// if recursive_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if recursive_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=recursive_mutex_unlock)
 recursive_mutex_guard :: proc(m: ^Recursive_Mutex) -> bool {
 	recursive_mutex_lock(m)
diff --git a/core/sync/sync2/primitives_atomic.odin b/core/sync/sync2/primitives_atomic.odin
index a13b73a99..5fc6fba85 100644
--- a/core/sync/sync2/primitives_atomic.odin
+++ b/core/sync/sync2/primitives_atomic.odin
@@ -82,13 +82,12 @@ atomic_mutex_try_lock :: proc(m: ^Atomic_Mutex) -> bool {
 	return ok
 }
 
-
-// Example:
-//
-// if atomic_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_mutex_unlock)
 atomic_mutex_guard :: proc(m: ^Atomic_Mutex) -> bool {
 	atomic_mutex_lock(m)
@@ -193,25 +192,24 @@ atomic_rw_mutex_try_shared_lock :: proc(rw: ^Atomic_RW_Mutex) -> bool {
 	return false
 }
 
-
-// Example:
-//
-// if atomic_rw_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_rw_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_rw_mutex_unlock)
 atomic_rw_mutex_guard :: proc(m: ^Atomic_RW_Mutex) -> bool {
 	atomic_rw_mutex_lock(m)
 	return true
 }
 
-// Example:
-//
-// if atomic_rw_mutex_shared_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_rw_mutex_shared_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_rw_mutex_shared_unlock)
 atomic_rw_mutex_shared_guard :: proc(m: ^Atomic_RW_Mutex) -> bool {
 	atomic_rw_mutex_shared_lock(m)
@@ -270,13 +268,12 @@ atomic_recursive_mutex_try_lock :: proc(m: ^Atomic_Recursive_Mutex) -> bool {
 	return true
 }
 
-
-// Example:
-//
-// if atomic_recursive_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_recursive_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_recursive_mutex_unlock)
 atomic_recursive_mutex_guard :: proc(m: ^Atomic_Recursive_Mutex) -> bool {
 	atomic_recursive_mutex_lock(m)
diff --git a/core/sync/sync2/sema_internal.odin b/core/sync/sync2/sema_internal.odin
index 64fc4ed96..f4027e908 100644
--- a/core/sync/sync2/sema_internal.odin
+++ b/core/sync/sync2/sema_internal.odin
@@ -1,3 +1,4 @@
+//+private
 package sync2
 
 import "core:time"
diff --git a/core/sync/sync2/sync_util.odin b/core/sync/sync2/sync_util.odin
index 853c3c685..013bf511a 100644
--- a/core/sync/sync2/sync_util.odin
+++ b/core/sync/sync2/sync_util.odin
@@ -1,12 +1,11 @@
 package sync2
 
-
-// Example:
-//
-// if guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if guard(&m) {
+		...
+	}
+*/
 guard :: proc{
 	mutex_guard,
 	rw_mutex_guard,
@@ -17,13 +16,12 @@ guard :: proc{
 	atomic_recursive_mutex_guard,
 	atomic_rw_mutex_guard,
 }
-
-// Example:
-//
-// if shared_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if shared_guard(&m) {
+		...
+	}
+*/
 shared_guard :: proc{
 	rw_mutex_shared_guard,
 	atomic_rw_mutex_shared_guard,
diff --git a/src/docs_format.cpp b/src/docs_format.cpp
index 38e7e20c2..f47fd0945 100644
--- a/src/docs_format.cpp
+++ b/src/docs_format.cpp
@@ -172,6 +172,8 @@ enum OdinDocEntityFlag : u64 {
 
 	OdinDocEntityFlag_Var_Thread_Local = 1ull<<40,
 	OdinDocEntityFlag_Var_Static       = 1ull<<41,
+
+	OdinDocEntityFlag_Private          = 1ull<<50,
 };
 
 struct OdinDocEntity {
diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp
index c2d07dc12..0a990cc37 100644
--- a/src/docs_writer.cpp
+++ b/src/docs_writer.cpp
@@ -815,7 +815,7 @@ OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) {
 	String link_name = {};
 
 	OdinDocEntityKind kind = OdinDocEntity_Invalid;
-	u32 flags = 0;
+	u64 flags = 0;
 	i32 field_group_index = -1;
 
 	switch (e->kind) {
@@ -866,6 +866,9 @@ OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) {
 		if (e->flags & EntityFlag_NoAlias)    { flags |= OdinDocEntityFlag_Param_NoAlias;  }
 		if (e->flags & EntityFlag_AnyInt)     { flags |= OdinDocEntityFlag_Param_AnyInt;   }
 	}
+	if (e->scope && (e->scope->flags & (ScopeFlag_File|ScopeFlag_Pkg)) && !is_entity_exported(e)) {
+		flags |= OdinDocEntityFlag_Private;
+	}
 
 	OdinDocString init_string = {};
 	if (init_expr) {
diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 89a82ad77..570950dfb 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -543,10 +543,13 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		e := entities[type_entites[0]]
 		name := str(type.name)
 		tn_pkg := files[e.pos.file].pkg
+
 		if tn_pkg != pkg {
 			fmt.wprintf(w, `%s.`, str(pkgs[tn_pkg].name))
 		}
-		if n := strings.contains_rune(name, '('); n >= 0 {
+		if .Private in e.flags {
+			io.write_string(w, name)
+		} else if n := strings.contains_rune(name, '('); n >= 0 {
 			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name[:n], BASE_CORE_URL)
 			io.write_string(w, name[n:])
 		} else {

From 5b97ff0b48a9bc717e5e5be225e23da9379e8cb6 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 00:13:26 +0000
Subject: [PATCH 22/37] General improves including comment formatting

---
 tools/odin-html-docs/footer.txt.html          |  13 +-
 tools/odin-html-docs/header.txt.html          |  30 +--
 tools/odin-html-docs/odin_html_docs_main.odin | 206 +++++++++++++-----
 tools/odin-html-docs/style.css                |  56 +++--
 4 files changed, 202 insertions(+), 103 deletions(-)

diff --git a/tools/odin-html-docs/footer.txt.html b/tools/odin-html-docs/footer.txt.html
index fbed3146a..548a00995 100644
--- a/tools/odin-html-docs/footer.txt.html
+++ b/tools/odin-html-docs/footer.txt.html
@@ -5,8 +5,8 @@
 	<div class="container pb-5 pt-5">
 		<div class="row g-4">
 		<div class="col">
-		<a class="navbar-brand" href="//odin-lang.org">
-		<img class="mb-3" src="//odin-lang.org/logo.svg" height="30" alt="Odin"></a>
+		<a class="navbar-brand" href="https://odin-lang.org">
+		<img class="mb-3" src="https://odin-lang.org/logo.svg" height="30" alt="Odin"></a>
 		<p>
 		The Data-Oriented Language for Sane Software Development.
 		</p>
@@ -14,8 +14,8 @@
 		<nav class="col-md-auto">
 			<h4 class="fw-normal">Resources</h4>
 			<ul class="list-unstyled">
-			<li><a href="//odin-lang.org/docs" class="link-light">Docs</a></li>
-			<li><a href="//odin-lang.org/news" class="link-light">Blog</a></li>
+			<li><a href="https://odin-lang.org/docs" class="link-light">Docs</a></li>
+			<li><a href="https://odin-lang.org/news" class="link-light">Blog</a></li>
 			</ul>
 		</nav>
 		<nav class="col-md-auto">
@@ -39,5 +39,6 @@
 	</div>
 </footer>
 
-<script src="//odin-lang.org/lib/bootstrap/js/bootstrap.min.js"></script>
-<script src="//odin-lang.org/js/script.js"></script>
\ No newline at end of file
+<script src="https://odin-lang.org/lib/bootstrap/js/bootstrap.min.js"></script>
+<script src="https://odin-lang.org/js/script.js"></script>
+<script>hljs.highlightAll()</script>
diff --git a/tools/odin-html-docs/header.txt.html b/tools/odin-html-docs/header.txt.html
index cfa1e0175..4bb9036e2 100644
--- a/tools/odin-html-docs/header.txt.html
+++ b/tools/odin-html-docs/header.txt.html
@@ -3,32 +3,4 @@
 <head>
 	<meta charset="utf-8">
 	<meta name="viewport" content="width=device-width, initial-scale=1">
-	<title>{0:s}</title>
-
-	<script type="text/javascript" src="https://livejs.com/live.js"></script>
-
-	<link rel="stylesheet" type="text/css" href="https://odin-lang.org/scss/custom.min.css">
-	<link rel="stylesheet" type="text/css" href="https://odin-lang.org/css/style.css">
-	<link rel="stylesheet" type="text/css" href="/style.css">
-
-	</style>
-</head>
-<body>
-<header class="sticky-top">
-	<nav class="navbar navbar-expand-lg navbar-dark bg-primary odin-menu">
-		<div class="container">
-			<a class="navbar-brand" href="/core">
-			<img src="//odin-lang.org/logo.svg" height="30" alt="Odin"></a>
-			<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#odin-navbar-content" aria-controls="odin-navbar-content" aria-expanded="false" aria-label="Toggle navigation"><span class="navbar-toggler-icon"></span></button>
-			<div class="collapse navbar-collapse" id="odin-navbar-content">
-			<ul class="navbar-nav ms-md-auto">
-				<li class="nav-item"><a class="nav-link" href="/core">Home</a></li>
-				<li class="nav-item"><a class="nav-link active" href="//odin-lang.org" aria-current="page">Language</a></li>
-				<li class="nav-item"><a class="nav-link" href="https://github.com/odin-lang/Odin" target="_blank">GitHub</a></li>
-			</ul>
-		</div>
-		</div>
-	</nav>
-</header>
-<main>
-<div class="container">
\ No newline at end of file
+	<title>{0:s}</title>
\ No newline at end of file
diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 570950dfb..79e9e4695 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -9,6 +9,7 @@ import "core:path/slashpath"
 import "core:sort"
 import "core:slice"
 
+GITHUB_LICENSE_URL :: "https://github.com/odin-lang/Odin/tree/master/LICENSE"
 GITHUB_CORE_URL :: "https://github.com/odin-lang/Odin/tree/master/core"
 BASE_CORE_URL :: "/core"
 
@@ -90,6 +91,7 @@ recursive_make_directory :: proc(path: string, prefix := "") {
 
 write_html_header :: proc(w: io.Writer, title: string) {
 	fmt.wprintf(w, string(#load("header.txt.html")), title)
+	io.write(w, #load("header-lower.txt.html"))
 }
 
 write_html_footer :: proc(w: io.Writer, include_directory_js: bool) {
@@ -289,19 +291,28 @@ generate_directory_tree :: proc() -> (root: ^Dir_Node) {
 }
 
 write_core_directory :: proc(w: io.Writer) {
-
 	root := generate_directory_tree()
 
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
+	{
+		fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
+		fmt.wprintln(w, "<header>")
+		fmt.wprintln(w, "<h1>Core Library Collection</h1>")
+		fmt.wprintln(w, "<ul>")
+		fmt.wprintf(w, "<li>License: <a href=\"{0:s}\">BSD-3-Clause</a></li>\n", GITHUB_LICENSE_URL)
+		fmt.wprintf(w, "<li>Repository: <a href=\"{0:s}\">{0:s}</a></li>\n", GITHUB_CORE_URL)
+		fmt.wprintln(w, "</ul>")
+		fmt.wprintln(w, "</header>")
+		fmt.wprintln(w, "</article>")
+		fmt.wprintln(w, "<hr>")
+	}
 	fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
 	defer fmt.wprintln(w, `</article>`)
 
-	fmt.wprintln(w, "<article>")
 	fmt.wprintln(w, "<header>")
-	fmt.wprintln(w, "<h1>Core Library Collection</h1>")
+	fmt.wprintln(w, `<h2><i class="bi bi-folder"></i>Directories</h2>`)
 	fmt.wprintln(w, "</header>")
-	fmt.wprintln(w, "</article>")
 
 	fmt.wprintln(w, "<div>")
 	fmt.wprintln(w, "\t<table class=\"doc-directory mt-4 mb-4\">")
@@ -802,57 +813,131 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 	if docs == "" {
 		return
 	}
-	it := docs
-	was_code := true
-	was_paragraph := true
-	prev_line: string
-	for line in strings.split_iterator(&it, "\n") {
-		text := strings.trim_space(line)
-		defer prev_line = line
+	Block_Kind :: enum {
+		Paragraph,
+		Code,
+	}
+	Block :: struct {
+		kind: Block_Kind,
+		lines: []string,
+	}
 
-		if strings.has_prefix(line, "\t") {
-			if !was_code {
-				was_code = true;
-				if prev_line == "Example:"  {
-					fmt.wprint(w, `<pre class="doc-code doc-code-example"><code>`)
-				} else {
-					fmt.wprint(w, `<pre class="doc-code"><code>`)
+	lines: [dynamic]string
+	it := docs
+	for line_ in strings.split_iterator(&it, "\n") {
+		line := strings.trim_right_space(line_)
+		append(&lines, line)
+	}
+
+	curr_block_kind := Block_Kind.Paragraph
+	start := 0
+	blocks: [dynamic]Block
+
+	for line, i in lines {
+		text := strings.trim_space(line)
+		switch curr_block_kind {
+		case .Paragraph:
+			if strings.has_prefix(line, "\t") {
+				if i-start > 0 {
+					append(&blocks, Block{curr_block_kind, lines[start:i]})
 				}
+				curr_block_kind, start = .Code, i
+			} else if text == "" {
+				if i-start > 0 {
+					append(&blocks, Block{curr_block_kind, lines[start:i]})
+				}
+				start = i
 			}
-			fmt.wprintf(w, "%s\n", strings.trim_prefix(line, "\t"))
-			continue
-		} else if was_code {
-			if text == "" {
+		case .Code:
+			if text == "" || strings.has_prefix(line, "\t") {
 				continue
 			}
-			was_code = false
-			fmt.wprintln(w, "</code></pre>")
-		}
-		if text == "" {
 
-			if was_paragraph {
-				was_paragraph = false
-				fmt.wprintln(w, "</p>")
+			if i-start > 0 {
+				append(&blocks, Block{curr_block_kind, lines[start:i]})
 			}
+			curr_block_kind, start = .Paragraph, i
+		}
+	}
+	if start < len(lines) {
+		if len(lines)-start > 0 {
+			append(&blocks, Block{curr_block_kind, lines[start:]})
+		}
+	}
+
+	for block in &blocks {
+		trim_amount := 0
+		for trim_amount = 0; trim_amount < len(block.lines); trim_amount += 1 {
+			line := block.lines[trim_amount]
+			if strings.trim_space(line) != "" {
+				break
+			}
+		}
+		block.lines = block.lines[trim_amount:]
+	}
+
+	for block, i in blocks {
+		if len(block.lines) == 0 {
 			continue
 		}
-		if !was_paragraph {
-			fmt.wprintln(w, "<p>")
+		prev_line := ""
+		if i > 0 {
+			prev_lines := blocks[i-1].lines
+			if len(prev_lines) > 0 {
+				prev_line = prev_lines[len(prev_lines)-1]
+			}
 		}
-		assert(!was_code)
+		prev_line = strings.trim_space(prev_line)
 
-		was_paragraph = true
-		write_doc_line(w, text)
+		lines := block.lines[:]
 
-		io.write_byte(w, '\n')
-	}
-	if was_code {
-		// assert(!was_paragraph, str(pkg.name))
-		was_code = false
-		fmt.wprintln(w, "</code></pre>")
-	}
-	if was_paragraph {
-		fmt.wprintln(w, "</p>")
+		end_line := block.lines[len(lines)-1]
+		if block.kind == .Paragraph && i+1 < len(blocks) {
+			if strings.has_prefix(end_line, "Example:") && blocks[i+1].kind == .Code {
+				lines = lines[:len(lines)-1]
+			}
+		}
+
+		switch block.kind {
+		case .Paragraph:
+			io.write_string(w, "<p>")
+			for line, line_idx in lines {
+				if line_idx > 0 {
+					io.write_string(w, "\n")
+				}
+				io.write_string(w, line)
+			}
+			io.write_string(w, "</p>\n")
+		case .Code:
+			all_blank := len(lines) > 0
+			for line in lines {
+				if strings.trim_space(line) != "" {
+					all_blank = false
+				}
+			}
+			if all_blank {
+				continue
+			}
+
+			if strings.has_prefix(prev_line, "Example:") {
+				io.write_string(w, "<details open class=\"code-example\">\n")
+				defer io.write_string(w, "</details>\n")
+				io.write_string(w, "<summary>Example:</summary>\n")
+				io.write_string(w, `<pre><code class="hljs" data-lang="odin">`)
+				for line in lines {
+					io.write_string(w, strings.trim_prefix(line, "\t"))
+					io.write_string(w, "\n")
+				}
+				io.write_string(w, "</code></pre>\n")
+			} else {
+				io.write_string(w, "<pre>")
+				for line in lines {
+					io.write_string(w, strings.trim_prefix(line, "\t"))
+					io.write_string(w, "\n")
+				}
+				io.write_string(w, "</pre>\n")
+			}
+		}
 	}
 }
 
@@ -860,7 +945,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
 
-	fmt.wprintln(w, `<article class="col-lg-9 p-4 documentation">`)
+	fmt.wprintln(w, `<article class="col-lg-9 p-4 documentation odin-article">`)
 
 	{ // breadcrumbs
 		fmt.wprintln(w, `<div class="row">`)
@@ -907,9 +992,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	}
 
 	fmt.wprintln(w, `<h2>Index</h2>`)
-	fmt.wprintln(w, `<section class="doc-index" id="pkg-index">`)
-	// fmt.wprintln(w, `<a class="btn btn-primary" data-bs-toggle="collapse" href="#pkg-index" role="button" aria-expanded="true" aria-controls="pkg-index"><h2>Index</h2></a>`)
-	// fmt.wprintln(w, `<section class="doc-index collapse" id="pkg-index">`)
+	fmt.wprintln(w, `<div id="pkg-index">`)
 	pkg_procs:       [dynamic]^doc.Entity
 	pkg_proc_groups: [dynamic]^doc.Entity
 	pkg_types:       [dynamic]^doc.Entity
@@ -944,8 +1027,16 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	slice.sort_by_key(pkg_consts[:],      entity_key)
 
 	write_index :: proc(w: io.Writer, name: string, entities: []^doc.Entity) {
-		fmt.wprintf(w, "<h3>%s</h3>\n", name)
-		fmt.wprintln(w, `<section class="doc-index">`)
+		fmt.wprintln(w, `<div>`)
+		defer fmt.wprintln(w, `</div>`)
+
+
+		fmt.wprintf(w, `<details open class="doc-index" id="doc-index-{0:s}" aria-labelledby="#doc-index-{0:s}-header">`+"\n", name)
+		fmt.wprintf(w, `<summary id="#doc-index-{0:s}-header">`+"\n", name)
+		io.write_string(w, name)
+		fmt.wprintln(w, `</summary>`)
+		defer fmt.wprintln(w, `</details>`)
+
 		if len(entities) == 0 {
 			io.write_string(w, "<p>This section is empty.</p>\n")
 		} else {
@@ -956,7 +1047,6 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			}
 			fmt.wprintln(w, "</ul>")
 		}
-		fmt.wprintln(w, "</section>")
 	}
 
 	entity_ordering := [?]struct{name: string, entities: []^doc.Entity} {
@@ -972,7 +1062,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		write_index(w, eo.name, eo.entities)
 	}
 
-	fmt.wprintln(w, "</section>")
+	fmt.wprintln(w, "</div>")
 
 
 	write_entity :: proc(w: io.Writer, e: ^doc.Entity) {
@@ -1008,6 +1098,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintf(w, "<div class=\"doc-source\"><a href=\"{0:s}\"><em>Source</em></a></div>", src_url)
 		}
 		fmt.wprintf(w, "</h3>\n")
+		fmt.wprintln(w, `<div>`)
 
 		switch e.kind {
 		case .Invalid, .Import_Name, .Library_Name:
@@ -1048,7 +1139,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			init_string := str(e.init_string)
 			if init_string != "" {
 				io.write_string(w, " = ")
-				io.write_string(w, init_string)
+				io.write_string(w, "…")
 			}
 			fmt.wprintln(w, "</pre>")
 
@@ -1099,8 +1190,15 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintln(w, "</pre>")
 
 		}
+		fmt.wprintln(w, `</div>`)
 
-		write_docs(w, pkg, strings.trim_space(str(e.docs)))
+		the_docs := strings.trim_space(str(e.docs))
+		if the_docs != "" {
+			fmt.wprintln(w, `<details class="odin-doc-toggle" open>`)
+			fmt.wprintln(w, `<summary class="hideme"><span>&nbsp;</span></summary>`)
+			write_docs(w, pkg, the_docs)
+			fmt.wprintln(w, `</details>`)
+		}
 	}
 	write_entities :: proc(w: io.Writer, title: string, entities: []^doc.Entity) {
 		fmt.wprintf(w, "<h2 id=\"pkg-{0:s}\">{0:s}</h2>\n", title)
@@ -1109,7 +1207,9 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			io.write_string(w, "<p>This section is empty.</p>\n")
 		} else {
 			for e in entities {
+				fmt.wprintln(w, `<div class="pkg-entity">`)
 				write_entity(w, e)
+				fmt.wprintln(w, `</div>`)
 			}
 		}
 		fmt.wprintln(w, "</section>")
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index cf3782c5d..c4f4c5ebf 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -25,10 +25,6 @@ table.`directory {
 	padding-right: 0;
 }
 
-.doc-directory tr[aria-controls]:hover {
-	background-color: #eee;
-}
-
 .doc-directory tr[aria-expanded=true] td.pkg-name:before {
 	content: "\2193";
 }
@@ -57,12 +53,12 @@ pre.doc-code {
 pre.doc-code a {
 	font-family: Consolas,Liberation Mono,Menlo,monospace!important;
 	text-decoration: none;
-	/*font-weight: bold;*/
-	color: #00bfd5;
+	color: #2179d8;
+	font-weight: 800;
 }
 
 pre.doc-code a.code-procedure {
-	color: #079300;
+	color: #047919;
 }
 
 .pkg-line-doc {
@@ -90,18 +86,48 @@ a > .a-hidden {
 a:hover > .a-hidden {
 	opacity: 100;
 }
-
-article.documentation h2 {
-	border-bottom: 1px dashed #c6c8ca;
-	padding-bottom: 0.5rem;
-}
 section.documentation h3 {
 	font-size: calc(1.1rem + .2vw);
 }
 
+.pkg-index h3 {
+	margin-top: 0  !important;
+	padding-top: 0 !important;
+}
 
 
-.doc-index h3 {
-	border-bottom: 1px solid #c6c8ca;
-	padding-bottom: 0.25rem;
+.documentation .pkg-entity {
+	padding-bottom: 0.75rem;
+	border-bottom: 1px solid #d0d0d0;
+}
+
+details.doc-index > summary {
+	position: relative;
+	font-size: 1.75rem;
+	left: -1.75rem;
+}
+details.doc-index ul {
+	list-style-type: none;
+}
+
+
+.odin-doc-toggle {
+
+}
+
+details.odin-doc-toggle[open] > summary.hideme {
+	margin-bottom: 0.5em;
+}
+
+details.odin-doc-toggle > summary.hideme {
+	cursor: pointer;
+}
+
+details.odin-doc-toggle[open] > summary.hideme span {
+	content: "";
+}
+
+
+details.code-example > summary {
+	font-weight: 700;
 }
\ No newline at end of file

From 3a3cb521abdce41ef9d7f7d8da9c1929710a58ff Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 00:19:24 +0000
Subject: [PATCH 23/37] Support tag printing

---
 tools/odin-html-docs/odin_html_docs_main.odin | 43 ++++++++++++-------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 79e9e4695..15e0ce074 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -528,8 +528,8 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			io.write_byte(w, '\n')
 		}
 	}
-	calc_name_width :: proc(type_entites: []doc.Entity_Index) -> (name_width: int) {
-		for entity_index in type_entites {
+	calc_name_width :: proc(type_entities: []doc.Entity_Index) -> (name_width: int) {
+		for entity_index in type_entities {
 			e := &entities[entity_index]
 			name := str(e.name)
 			name_width = max(len(name), name_width)
@@ -538,7 +538,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 	}
 
 
-	type_entites := array(type.entities)
+	type_entities := array(type.entities)
 	type_types := array(type.types)
 	switch type.kind {
 	case .Invalid:
@@ -551,7 +551,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			fmt.wprintf(w, `<a href="">%s</a>`, str(type.name))
 		}
 	case .Named:
-		e := entities[type_entites[0]]
+		e := entities[type_entities[0]]
 		name := str(type.name)
 		tn_pkg := files[e.pos.file].pkg
 
@@ -616,19 +616,30 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 			io.write_string(w, custom_align)
 		}
 		io.write_string(w, " {")
-		if len(type_entites) != 0 {
+
+		tags := array(type.tags)
+
+		if len(type_entities) != 0 {
 			do_newline(writer, flags)
 			indent += 1
-			name_width := calc_name_width(type_entites)
+			name_width := calc_name_width(type_entities)
 
-			for entity_index, i in type_entites {
+			for entity_index, i in type_entities {
 				e := &entities[entity_index]
 				next_entity: ^doc.Entity = nil
-				if i+1 < len(type_entites) {
-					next_entity = &entities[type_entites[i+1]]
+				if i+1 < len(type_entities) {
+					next_entity = &entities[type_entities[i+1]]
 				}
 				do_indent(writer, flags)
 				write_param_entity(writer, e, next_entity, flags, name_width)
+
+				if len(tags) == len(type_entities) {
+					if tag := str(tags[i]); tag != "" {
+						io.write_byte(w, ' ')
+						io.write_quoted_string(w, tag)
+					}
+				}
+
 				io.write_byte(w, ',')
 				do_newline(writer, flags)
 			}
@@ -670,9 +681,9 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		do_newline(writer, flags)
 		indent += 1
 
-		name_width := calc_name_width(type_entites)
+		name_width := calc_name_width(type_entities)
 
-		for entity_index in type_entites {
+		for entity_index in type_entities {
 			e := &entities[entity_index]
 
 			name := str(e.name)
@@ -693,19 +704,19 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		do_indent(writer, flags)
 		io.write_string(w, "}")
 	case .Tuple:
-		if len(type_entites) == 0 {
+		if len(type_entities) == 0 {
 			return
 		}
-		require_parens := (.Is_Results in flags) && (len(type_entites) > 1 || !is_entity_blank(type_entites[0]))
+		require_parens := (.Is_Results in flags) && (len(type_entities) > 1 || !is_entity_blank(type_entities[0]))
 		if require_parens { io.write_byte(w, '(') }
-		for entity_index, i in type_entites {
+		for entity_index, i in type_entities {
 			if i > 0 {
 				io.write_string(w, ", ")
 			}
 			e := &entities[entity_index]
 			next_entity: ^doc.Entity = nil
-			if i+1 < len(type_entites) {
-				next_entity = &entities[type_entites[i+1]]
+			if i+1 < len(type_entities) {
+				next_entity = &entities[type_entities[i+1]]
 			}
 			write_param_entity(writer, e, next_entity, flags)
 		}

From d39c05b1839b36f95e33bbaf5087351e31abf2a6 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 00:19:58 +0000
Subject: [PATCH 24/37] Simplify tag printing

---
 tools/odin-html-docs/odin_html_docs_main.odin | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 15e0ce074..10d5ebe37 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -633,11 +633,9 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 				do_indent(writer, flags)
 				write_param_entity(writer, e, next_entity, flags, name_width)
 
-				if len(tags) == len(type_entities) {
-					if tag := str(tags[i]); tag != "" {
-						io.write_byte(w, ' ')
-						io.write_quoted_string(w, tag)
-					}
+				if tag := str(tags[i]); tag != "" {
+					io.write_byte(w, ' ')
+					io.write_quoted_string(w, tag)
 				}
 
 				io.write_byte(w, ',')

From b612edba5a7322bede879627d3b39f4587deccfe Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 00:36:44 +0000
Subject: [PATCH 25/37] Improve detail styling

---
 tools/odin-html-docs/style.css | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index c4f4c5ebf..86b43323d 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -110,24 +110,18 @@ details.doc-index ul {
 	list-style-type: none;
 }
 
-
-.odin-doc-toggle {
-
+details.odin-doc-toggle > summary.hideme span:before {
+	content: "Expand description";
+}
+details.odin-doc-toggle[open] > summary.hideme span:before {
+	content: "Close description";
+	opacity: 0.8;
 }
 
 details.odin-doc-toggle[open] > summary.hideme {
 	margin-bottom: 0.5em;
 }
 
-details.odin-doc-toggle > summary.hideme {
-	cursor: pointer;
-}
-
-details.odin-doc-toggle[open] > summary.hideme span {
-	content: "";
-}
-
-
 details.code-example > summary {
 	font-weight: 700;
 }
\ No newline at end of file

From 1b23dd225775758959241b79fbfedb02129372dd Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 01:02:26 +0000
Subject: [PATCH 26/37] Add home page

---
 tools/odin-html-docs/odin_html_docs_main.odin | 56 ++++++++++++++++++-
 tools/odin-html-docs/style.css                | 17 +++++-
 2 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 10d5ebe37..7f2e7b59f 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -209,6 +209,15 @@ main :: proc() {
 	b := strings.make_builder()
 	defer strings.destroy_builder(&b)
 	w := strings.to_writer(&b)
+
+	{
+		strings.reset_builder(&b)
+		write_html_header(w, "Packages - pkg.odin-lang.org")
+		write_home_page(w)
+		write_html_footer(w, true)
+		os.write_entire_file("index.html", b.buf[:])
+	}
+
 	{
 		strings.reset_builder(&b)
 		write_html_header(w, "core library - pkg.odin-lang.org")
@@ -228,6 +237,49 @@ main :: proc() {
 	}
 }
 
+write_home_page :: proc(w: io.Writer) {
+	fmt.wprintln(w, `<div class="row odin-main">`)
+	defer fmt.wprintln(w, `</div>`)
+
+	{
+		fmt.wprintln(w, `<nav class="col-lg-2 odin-sidebar-border navbar-light">`)
+		defer fmt.wprintln(w, `</nav>`)
+		fmt.wprintln(w, `<div class="sticky-top odin-below-navbar py-3">`)
+		defer fmt.wprintln(w, `</div>`)
+
+		fmt.wprintln(w, `<ul class="nav nav-pills d-flex flex-column">`)
+		fmt.wprintln(w, `<li class="nav-item"><a class="nav-link" href="/core">Core Library</a></li>`)
+		fmt.wprintln(w, `<li class="nav-item"><a class="nav-link" href="#">Vendor Library</a></li>`)
+		fmt.wprintln(w, `</ul>`)
+
+	}
+
+
+	fmt.wprintln(w, `<article class="col-lg-8 p-4">`)
+	defer fmt.wprintln(w, `</article>`)
+
+	fmt.wprintln(w, "<article><header>")
+	fmt.wprintln(w, "<h1>Odin Packages</h1>")
+	fmt.wprintln(w, "</header></article>")
+	fmt.wprintln(w, "<div>")
+	defer fmt.wprintln(w, "</div>")
+
+	fmt.wprintln(w, `<div class="mt-5">`)
+	fmt.wprintln(w, `<a href="/core" class="link-primary text-decoration-node"><h3>Core Library Collection</h3></a>`)
+	fmt.wprintln(w, `<p>Documentation for all the packages part of the <code>core</code> library collection.</p>`)
+	fmt.wprintln(w, `</div>`)
+
+	fmt.wprintln(w, `<div class="mt-5">`)
+	fmt.wprintln(w, `<a href="#" class="link-primary text-decoration-node"><h3>Vendor Library Collection</h3></a>`)
+	fmt.wprintln(w, `<p>Documentation for all the packages part of the <code>vendor</code> library collection.</p>`)
+	fmt.wprintln(w, `<p><em>Coming Soon.</em></p>`)
+	fmt.wprintln(w, `</div>`)
+
+
+
+}
+
+
 
 Dir_Node :: struct {
 	dir: string,
@@ -297,7 +349,7 @@ write_core_directory :: proc(w: io.Writer) {
 	defer fmt.wprintln(w, `</div>`)
 	{
 		fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
-		fmt.wprintln(w, "<header>")
+		fmt.wprintln(w, `<header class="collection-header">`)
 		fmt.wprintln(w, "<h1>Core Library Collection</h1>")
 		fmt.wprintln(w, "<ul>")
 		fmt.wprintf(w, "<li>License: <a href=\"{0:s}\">BSD-3-Clause</a></li>\n", GITHUB_LICENSE_URL)
@@ -305,7 +357,7 @@ write_core_directory :: proc(w: io.Writer) {
 		fmt.wprintln(w, "</ul>")
 		fmt.wprintln(w, "</header>")
 		fmt.wprintln(w, "</article>")
-		fmt.wprintln(w, "<hr>")
+		fmt.wprintln(w, `<hr class="collection-hr">`)
 	}
 	fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
 	defer fmt.wprintln(w, `</article>`)
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index 86b43323d..cb06a8603 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -1,11 +1,24 @@
 /* doc directories */
 
-table.`directory {
+table.directory {
 	/*border: 1px solid #ccc!important;*/
 	table-layout: fixed;
 	border-collapse: collapse;
 }
 
+header.collection-header ul {
+	margin-top: 1em;
+	margin-bottom: 0;
+	padding-left: 0.5em;
+	list-style-type: none;
+}
+
+hr.collection-hr {
+	margin: 0;
+	padding: 0;
+}
+
+
 .doc-directory tr {
 	padding-left: 1em!important;
 	border-top: 1px solid #ccc!important;
@@ -124,4 +137,4 @@ details.odin-doc-toggle[open] > summary.hideme {
 
 details.code-example > summary {
 	font-weight: 700;
-}
\ No newline at end of file
+}

From cfbc1a447bba4e3648d9e15c1f776d6d8068951e Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 20 Jan 2022 13:18:37 +0000
Subject: [PATCH 27/37] Correct inverse and inverse_transpose for 2x2 matrices

---
 core/runtime/core_builtin_matrix.odin | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/core/runtime/core_builtin_matrix.odin b/core/runtime/core_builtin_matrix.odin
index 08dca288e..53589587c 100644
--- a/core/runtime/core_builtin_matrix.odin
+++ b/core/runtime/core_builtin_matrix.odin
@@ -146,14 +146,14 @@ matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y:
 	d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0]
 	when intrinsics.type_is_integer(T) {
 		y[0, 0] = +x[1, 1] / d
-		y[1, 0] = -x[1, 0] / d
-		y[0, 1] = -x[0, 1] / d
+		y[1, 0] = -x[0, 1] / d
+		y[0, 1] = -x[1, 0] / d
 		y[1, 1] = +x[0, 0] / d
 	} else {
 		id := 1 / d
 		y[0, 0] = +x[1, 1] * id
-		y[1, 0] = -x[1, 0] * id
-		y[0, 1] = -x[0, 1] * id
+		y[1, 0] = -x[0, 1] * id
+		y[0, 1] = -x[1, 0] * id
 		y[1, 1] = +x[0, 0] * id
 	}
 	return
@@ -214,16 +214,16 @@ matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {
 matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {
 	d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0]
 	when intrinsics.type_is_integer(T) {
-		y[0, 0] = x[1, 1] / d
-		y[0, 1] = x[1, 0] / d
-		y[1, 0] = x[0, 1] / d
-		y[1, 1] = x[0, 0] / d
+		y[0, 0] = +x[1, 1] / d
+		y[0, 1] = -x[0, 1] / d
+		y[1, 0] = -x[1, 0] / d
+		y[1, 1] = +x[0, 0] / d
 	} else {
 		id := 1 / d
-		y[0, 0] = x[1, 1] * id
-		y[0, 1] = x[1, 0] * id
-		y[1, 0] = x[0, 1] * id
-		y[1, 1] = x[0, 0] * id
+		y[0, 0] = +x[1, 1] * id
+		y[0, 1] = -x[0, 1] * id
+		y[1, 0] = -x[1, 0] * id
+		y[1, 1] = +x[0, 0] * id
 	}
 	return
 }

From 0e0638362015665411d1454a1a7292de9fe97fed Mon Sep 17 00:00:00 2001
From: Platin21 <arminmops@icloud.com>
Date: Sat, 22 Jan 2022 17:34:43 +0100
Subject: [PATCH 28/37] Changed make file so that it allows for multiple LLVM
 versions instead of a single one on Darwin

---
 Makefile | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/Makefile b/Makefile
index a7aecbb2d..6acecccc4 100644
--- a/Makefile
+++ b/Makefile
@@ -11,19 +11,23 @@ ifeq ($(OS), Darwin)
     ARCH=$(shell uname -m)
     LLVM_CONFIG=llvm-config
 
-    # LLVM Version Setting  
-    LLVM_VERSION_PATTERN="^11\."
-    LLVM_VERSION="11"
     ifeq ($(ARCH), arm64)
-	LLVM_VERSION="13"
-        LLVM_VERSION_PATTERN="^13"
-    endif 
-
-    ifneq ($(shell llvm-config --version | grep $(LLVM_VERSION_PATTERN)),)
-        LLVM_CONFIG=llvm-config
+        ifneq ($(shell llvm-config --version | grep "^13\."),)
+            LLVM_CONFIG=llvm-config
+        else
+            $(error "Requirement: llvm-config must be version llvm 13 for arm64")
+        endif
     else
-        $(error "Requirement: llvm-config must be version $(LLVM_VERSION)")
-    endif
+        ifneq ($(shell llvm-config --version | grep "^11\."),)
+            LLVM_CONFIG=llvm-config
+        else ifneq ($(shell llvm-config --version | grep "^12\."),)
+            LLVM_CONFIG=llvm-config
+        else ifneq ($(shell llvm-config --version | grep "^13\."),)
+            LLVM_CONFIG=llvm-config
+        else
+            $(error "Requirement: llvm-config must be version llvm 11 or 12 or 13 for amd64/x86")
+        endif
+    endif 
 
     LDFLAGS:=$(LDFLAGS) -liconv
     CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)

From fe6539fad9e83f20d2e45b377e57353dfb6b3a96 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 22 Jan 2022 17:03:55 +0000
Subject: [PATCH 29/37] Add more to examples/all/all_vendor.odin

---
 examples/all/all_vendor.odin | 45 ++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 12 deletions(-)

diff --git a/examples/all/all_vendor.odin b/examples/all/all_vendor.odin
index 777c184f9..f94e092af 100644
--- a/examples/all/all_vendor.odin
+++ b/examples/all/all_vendor.odin
@@ -1,26 +1,47 @@
 //+build windows
 package all
 
-import glfw   "vendor:glfw"
-import gl     "vendor:OpenGL"
-import rl     "vendor:raylib"
-import PM     "vendor:portmidi"
+
+import botan     "vendor:botan"
+import ENet      "vendor:ENet"
+import gl        "vendor:OpenGL"
+import glfw      "vendor:glfw"
+import microui   "vendor:microui"
+import miniaudio "vendor:miniaudio"
+import PM        "vendor:portmidi"
+import rl        "vendor:raylib"
+
 import SDL    "vendor:sdl2"
-import IMG    "vendor:sdl2/image"
 import SDLNet "vendor:sdl2/net"
+import IMG    "vendor:sdl2/image"
 import MIX    "vendor:sdl2/mixer"
 import TTF    "vendor:sdl2/ttf"
-import vk     "vendor:vulkan"
-import ENet   "vendor:ENet"
 
-_ :: glfw
+import stb_easy_font "vendor:stb/easy_font"
+import stbi          "vendor:stb/image"
+import stbrp         "vendor:stb/rect_pack"
+import stbtt         "vendor:stb/truetype"
+import stb_vorbis    "vendor:stb/vorbis"
+
+import vk "vendor:vulkan"
+
+
+_ :: botan
+_ :: ENet
 _ :: gl
-_ :: rl
+_ :: glfw
+_ :: microui
+_ :: miniaudio
 _ :: PM
+_ :: rl
 _ :: SDL
-_ :: IMG
 _ :: SDLNet
+_ :: IMG
 _ :: MIX
 _ :: TTF
-_ :: vk
-_ :: ENet
\ No newline at end of file
+_ :: stb_easy_font
+_ :: stbi
+_ :: stbrp
+_ :: stbtt
+_ :: stb_vorbis
+_ :: vk
\ No newline at end of file

From fdcb9deaffed29f8b528cb4a8bf30693a7894b2c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 22 Jan 2022 17:07:24 +0000
Subject: [PATCH 30/37] Generate core and vendor library collection; add
 package sidebar for the entire collection

---
 tools/odin-html-docs/odin_html_docs_main.odin | 262 +++++++++++++-----
 tools/odin-html-docs/style.css                |  27 +-
 2 files changed, 221 insertions(+), 68 deletions(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index 7f2e7b59f..e5d46547a 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -8,10 +8,13 @@ import "core:strings"
 import "core:path/slashpath"
 import "core:sort"
 import "core:slice"
+import "core:time"
 
 GITHUB_LICENSE_URL :: "https://github.com/odin-lang/Odin/tree/master/LICENSE"
 GITHUB_CORE_URL :: "https://github.com/odin-lang/Odin/tree/master/core"
+GITHUB_VENDOR_URL :: "https://github.com/odin-lang/Odin/tree/master/vendor"
 BASE_CORE_URL :: "/core"
+BASE_VENDOR_URL :: "/vendor"
 
 header:   ^doc.Header
 files:    []doc.File
@@ -19,8 +22,18 @@ pkgs:     []doc.Pkg
 entities: []doc.Entity
 types:    []doc.Type
 
-pkgs_to_use: map[string]^doc.Pkg // trimmed path
+core_pkgs_to_use: map[string]^doc.Pkg // trimmed path
+vendor_pkgs_to_use: map[string]^doc.Pkg // trimmed path
 pkg_to_path: map[^doc.Pkg]string // trimmed path
+pkg_to_collection: map[^doc.Pkg]^Collection
+
+Collection :: struct {
+	name: string,
+	pkgs_to_use: ^map[string]^doc.Pkg,
+	github_url: string,
+	base_url:   string,
+	root: ^Dir_Node,
+}
 
 array :: proc(a: $A/doc.Array($T)) -> []T {
 	return doc.from_array(header, a)
@@ -175,6 +188,21 @@ main :: proc() {
 	entities = array(header.entities)
 	types    = array(header.types)
 
+	core_collection := &Collection{
+		"Core",
+		&core_pkgs_to_use,
+		GITHUB_CORE_URL,
+		BASE_CORE_URL,
+		nil,
+	}
+	vendor_collection := &Collection{
+		"Vendor",
+		&vendor_pkgs_to_use,
+		GITHUB_VENDOR_URL,
+		BASE_VENDOR_URL,
+		nil,
+	}
+
 	{
 		fullpaths: [dynamic]string
 		defer delete(fullpaths)
@@ -184,25 +212,38 @@ main :: proc() {
 		}
 		path_prefix := common_prefix(fullpaths[:])
 
-		pkgs_to_use = make(map[string]^doc.Pkg)
+		core_pkgs_to_use = make(map[string]^doc.Pkg)
+		vendor_pkgs_to_use = make(map[string]^doc.Pkg)
 		fullpath_loop: for fullpath, i in fullpaths {
 			path := strings.trim_prefix(fullpath, path_prefix)
-			if !strings.has_prefix(path, "core/") {
-				continue fullpath_loop
-			}
 			pkg := &pkgs[i+1]
 			if len(array(pkg.entities)) == 0 {
 				continue fullpath_loop
 			}
-			trimmed_path := strings.trim_prefix(path, "core/")
-			if strings.has_prefix(trimmed_path, "sys") {
-				continue fullpath_loop
-			}
 
-			pkgs_to_use[trimmed_path] = pkg
+			switch {
+			case strings.has_prefix(path, "core/"):
+				trimmed_path := strings.trim_prefix(path, "core/")
+				if strings.has_prefix(trimmed_path, "sys") {
+					continue fullpath_loop
+				}
+
+				core_pkgs_to_use[trimmed_path] = pkg
+			case strings.has_prefix(path, "vendor/"):
+				trimmed_path := strings.trim_prefix(path, "vendor/")
+				if strings.contains(trimmed_path, "/bindings") {
+					continue fullpath_loop
+				}
+				vendor_pkgs_to_use[trimmed_path] = pkg
+			}
 		}
-		for path, pkg in pkgs_to_use {
+		for path, pkg in core_pkgs_to_use {
 			pkg_to_path[pkg] = path
+			pkg_to_collection[pkg] = core_collection
+		}
+		for path, pkg in vendor_pkgs_to_use {
+			pkg_to_path[pkg] = path
+			pkg_to_collection[pkg] = vendor_collection
 		}
 	}
 
@@ -218,42 +259,53 @@ main :: proc() {
 		os.write_entire_file("index.html", b.buf[:])
 	}
 
+	core_collection.root   = generate_directory_tree(core_pkgs_to_use)
+	vendor_collection.root = generate_directory_tree(vendor_pkgs_to_use)
+
+	generate_packages(&b, core_collection, "core")
+	generate_packages(&b, vendor_collection, "vendor")
+}
+
+generate_packages :: proc(b: ^strings.Builder, collection: ^Collection, dir: string) {
+	w := strings.to_writer(b)
+
 	{
-		strings.reset_builder(&b)
-		write_html_header(w, "core library - pkg.odin-lang.org")
-		write_core_directory(w)
+		strings.reset_builder(b)
+		write_html_header(w, fmt.tprintf("%s library - pkg.odin-lang.org", dir))
+		write_collection_directory(w, collection)
 		write_html_footer(w, true)
-		os.make_directory("core", 0)
-		os.write_entire_file("core/index.html", b.buf[:])
+		os.make_directory(dir, 0)
+		os.write_entire_file(fmt.tprintf("%s/index.html", dir), b.buf[:])
 	}
 
-	for path, pkg in pkgs_to_use {
-		strings.reset_builder(&b)
+	for path, pkg in collection.pkgs_to_use {
+		strings.reset_builder(b)
 		write_html_header(w, fmt.tprintf("package %s - pkg.odin-lang.org", path))
-		write_pkg(w, path, pkg)
+		write_pkg(w, path, pkg, collection)
 		write_html_footer(w, false)
-		recursive_make_directory(path, "core")
-		os.write_entire_file(fmt.tprintf("core/%s/index.html", path), b.buf[:])
+		recursive_make_directory(path, dir)
+		os.write_entire_file(fmt.tprintf("%s/%s/index.html", dir, path), b.buf[:])
 	}
 }
 
+
+write_home_sidebar :: proc(w: io.Writer) {
+	fmt.wprintln(w, `<nav class="col-lg-2 odin-sidebar-border navbar-light">`)
+	defer fmt.wprintln(w, `</nav>`)
+	fmt.wprintln(w, `<div class="sticky-top odin-below-navbar py-3">`)
+	defer fmt.wprintln(w, `</div>`)
+
+	fmt.wprintln(w, `<ul class="nav nav-pills d-flex flex-column">`)
+	fmt.wprintln(w, `<li class="nav-item"><a class="nav-link" href="/core">Core Library</a></li>`)
+	fmt.wprintln(w, `<li class="nav-item"><a class="nav-link" href="/vendor">Vendor Library</a></li>`)
+	fmt.wprintln(w, `</ul>`)
+}
+
 write_home_page :: proc(w: io.Writer) {
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
 
-	{
-		fmt.wprintln(w, `<nav class="col-lg-2 odin-sidebar-border navbar-light">`)
-		defer fmt.wprintln(w, `</nav>`)
-		fmt.wprintln(w, `<div class="sticky-top odin-below-navbar py-3">`)
-		defer fmt.wprintln(w, `</div>`)
-
-		fmt.wprintln(w, `<ul class="nav nav-pills d-flex flex-column">`)
-		fmt.wprintln(w, `<li class="nav-item"><a class="nav-link" href="/core">Core Library</a></li>`)
-		fmt.wprintln(w, `<li class="nav-item"><a class="nav-link" href="#">Vendor Library</a></li>`)
-		fmt.wprintln(w, `</ul>`)
-
-	}
-
+	write_home_sidebar(w)
 
 	fmt.wprintln(w, `<article class="col-lg-8 p-4">`)
 	defer fmt.wprintln(w, `</article>`)
@@ -270,9 +322,8 @@ write_home_page :: proc(w: io.Writer) {
 	fmt.wprintln(w, `</div>`)
 
 	fmt.wprintln(w, `<div class="mt-5">`)
-	fmt.wprintln(w, `<a href="#" class="link-primary text-decoration-node"><h3>Vendor Library Collection</h3></a>`)
+	fmt.wprintln(w, `<a href="/vendor" class="link-primary text-decoration-node"><h3>Vendor Library Collection</h3></a>`)
 	fmt.wprintln(w, `<p>Documentation for all the packages part of the <code>vendor</code> library collection.</p>`)
-	fmt.wprintln(w, `<p><em>Coming Soon.</em></p>`)
 	fmt.wprintln(w, `</div>`)
 
 
@@ -289,7 +340,7 @@ Dir_Node :: struct {
 	children: [dynamic]^Dir_Node,
 }
 
-generate_directory_tree :: proc() -> (root: ^Dir_Node) {
+generate_directory_tree :: proc(pkgs_to_use: map[string]^doc.Pkg) -> (root: ^Dir_Node) {
 	sort_tree :: proc(node: ^Dir_Node) {
 		slice.sort_by_key(node.children[:], proc(node: ^Dir_Node) -> string {return node.name})
 		for child in node.children {
@@ -342,25 +393,46 @@ generate_directory_tree :: proc() -> (root: ^Dir_Node) {
 	return
 }
 
-write_core_directory :: proc(w: io.Writer) {
-	root := generate_directory_tree()
+write_collection_directory :: proc(w: io.Writer, collection: ^Collection) {
+	get_line_doc :: proc(pkg: ^doc.Pkg) -> (line_doc: string, ok: bool) {
+		if pkg == nil {
+			return
+		}
+		line_doc, _, _ = strings.partition(str(pkg.docs), "\n")
+		line_doc = strings.trim_space(line_doc)
+		if line_doc == "" {
+			return
+		}
+		switch {
+		case strings.has_prefix(line_doc, "*"):
+			return "", false
+		case strings.has_prefix(line_doc, "Copyright"):
+			return "", false
+		}
+		return line_doc, true
+	}
+
 
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
+
+
+	write_home_sidebar(w)
+
+	fmt.wprintln(w, `<article class="col-lg-10 p-4">`)
+	defer fmt.wprintln(w, `</article>`)
 	{
-		fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
+		fmt.wprintln(w, `<article class="p-4">`)
 		fmt.wprintln(w, `<header class="collection-header">`)
-		fmt.wprintln(w, "<h1>Core Library Collection</h1>")
+		fmt.wprintf(w, "<h1>%s Library Collection</h1>\n", collection.name)
 		fmt.wprintln(w, "<ul>")
 		fmt.wprintf(w, "<li>License: <a href=\"{0:s}\">BSD-3-Clause</a></li>\n", GITHUB_LICENSE_URL)
-		fmt.wprintf(w, "<li>Repository: <a href=\"{0:s}\">{0:s}</a></li>\n", GITHUB_CORE_URL)
+		fmt.wprintf(w, "<li>Repository: <a href=\"{0:s}\">{0:s}</a></li>\n", collection.github_url)
 		fmt.wprintln(w, "</ul>")
 		fmt.wprintln(w, "</header>")
 		fmt.wprintln(w, "</article>")
 		fmt.wprintln(w, `<hr class="collection-hr">`)
 	}
-	fmt.wprintln(w, `<article class="col-lg-12 p-4">`)
-	defer fmt.wprintln(w, `</article>`)
 
 	fmt.wprintln(w, "<header>")
 	fmt.wprintln(w, `<h2><i class="bi bi-folder"></i>Directories</h2>`)
@@ -370,7 +442,7 @@ write_core_directory :: proc(w: io.Writer) {
 	fmt.wprintln(w, "\t<table class=\"doc-directory mt-4 mb-4\">")
 	fmt.wprintln(w, "\t\t<tbody>")
 
-	for dir in root.children {
+	for dir in collection.root.children {
 		if len(dir.children) != 0 {
 			fmt.wprint(w, `<tr aria-controls="`)
 			for child in dir.children {
@@ -386,18 +458,16 @@ write_core_directory :: proc(w: io.Writer) {
 		}
 
 		if dir.pkg != nil {
-			fmt.wprintf(w, `<a href="%s/%s">%s</a>`, BASE_CORE_URL, dir.path, dir.name)
+			fmt.wprintf(w, `<a href="%s/%s">%s</a>`, collection.base_url, dir.path, dir.name)
 		} else {
 			fmt.wprintf(w, "%s", dir.name)
 		}
 		io.write_string(w, `</td>`)
 		io.write_string(w, `<td class="pkg-line pkg-line-doc">`)
-		if dir.pkg != nil {
-			line_doc, _, _ := strings.partition(str(dir.pkg.docs), "\n")
-			line_doc = strings.trim_space(line_doc)
-			if line_doc != "" {
-				write_doc_line(w, line_doc)
-			}
+		if line_doc, ok := get_line_doc(dir.pkg); ok {
+			write_doc_line(w, line_doc)
+		} else {
+			io.write_string(w, `&nbsp;`)
 		}
 		io.write_string(w, `</td>`)
 		fmt.wprintf(w, "</tr>\n")
@@ -405,14 +475,16 @@ write_core_directory :: proc(w: io.Writer) {
 		for child in dir.children {
 			assert(child.pkg != nil)
 			fmt.wprintf(w, `<tr id="pkg-%s" class="directory-pkg directory-child"><td class="pkg-line pkg-name">`, str(child.pkg.name))
-			fmt.wprintf(w, `<a href="%s/%s/">%s</a>`, BASE_CORE_URL, child.path, child.name)
+			fmt.wprintf(w, `<a href="%s/%s/">%s</a>`, collection.base_url, child.path, child.name)
 			io.write_string(w, `</td>`)
 
 			line_doc, _, _ := strings.partition(str(child.pkg.docs), "\n")
 			line_doc = strings.trim_space(line_doc)
 			io.write_string(w, `<td class="pkg-line pkg-line-doc">`)
-			if line_doc != "" {
+			if line_doc, ok := get_line_doc(dir.pkg); ok {
 				write_doc_line(w, line_doc)
+			} else {
+				io.write_string(w, `&nbsp;`)
 			}
 			io.write_string(w, `</td>`)
 
@@ -606,6 +678,7 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		e := entities[type_entities[0]]
 		name := str(type.name)
 		tn_pkg := files[e.pos.file].pkg
+		collection: Collection // TODO determine this from package
 
 		if tn_pkg != pkg {
 			fmt.wprintf(w, `%s.`, str(pkgs[tn_pkg].name))
@@ -613,10 +686,10 @@ write_type :: proc(using writer: ^Type_Writer, type: doc.Type, flags: Write_Type
 		if .Private in e.flags {
 			io.write_string(w, name)
 		} else if n := strings.contains_rune(name, '('); n >= 0 {
-			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name[:n], BASE_CORE_URL)
+			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name[:n], collection.base_url)
 			io.write_string(w, name[n:])
 		} else {
-			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name, BASE_CORE_URL)
+			fmt.wprintf(w, `<a class="code-typename" href="{2:s}/{0:s}/#{1:s}">{1:s}</a>`, pkg_to_path[&pkgs[tn_pkg]], name, collection.base_url)
 		}
 	case .Generic:
 		name := str(type.name)
@@ -870,6 +943,10 @@ write_doc_line :: proc(w: io.Writer, text: string) {
 	}
 }
 
+write_doc_sidebar :: proc(w: io.Writer) {
+
+}
+
 write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 	if docs == "" {
 		return
@@ -1002,13 +1079,55 @@ write_docs :: proc(w: io.Writer, pkg: ^doc.Pkg, docs: string) {
 	}
 }
 
-write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
+write_pkg_sidebar :: proc(w: io.Writer, curr_pkg: ^doc.Pkg, collection: ^Collection) {
+
+	fmt.wprintln(w, `<nav id="pkg-sidebar" class="col-lg-2 odin-sidebar-border navbar-light">`)
+	defer fmt.wprintln(w, `</nav>`)
+	fmt.wprintln(w, `<div class="sticky-top odin-below-navbar py-3">`)
+	defer fmt.wprintln(w, `</div>`)
+
+	fmt.wprintf(w, "<h4>%s Library</h4>\n", collection.name)
+
+	fmt.wprintln(w, `<ul>`)
+	defer fmt.wprintln(w, `</ul>`)
+
+	for dir in collection.root.children {
+		fmt.wprint(w, `<li class="nav-item">`)
+		defer fmt.wprintln(w, `</li>`)
+		if dir.pkg == curr_pkg {
+			fmt.wprintf(w, `<a class="active" href="%s/%s">%s</a>`, collection.base_url, dir.path, dir.name)
+		} else if dir.pkg != nil {
+			fmt.wprintf(w, `<a href="%s/%s">%s</a>`, collection.base_url, dir.path, dir.name)
+		} else {
+			fmt.wprintf(w, "%s", dir.name)
+		}
+		if len(dir.children) != 0 {
+			fmt.wprintln(w, "<ul>")
+			defer fmt.wprintln(w, "</ul>\n")
+			for child in dir.children {
+				fmt.wprint(w, `<li>`)
+				defer fmt.wprintln(w, `</li>`)
+				if child.pkg == curr_pkg {
+					fmt.wprintf(w, `<a class="active" href="%s/%s">%s</a>`, collection.base_url, child.path, child.name)
+				} else if child.pkg != nil {
+					fmt.wprintf(w, `<a href="%s/%s">%s</a>`, collection.base_url, child.path, child.name)
+				} else {
+					fmt.wprintf(w, "%s", child.name)
+				}
+			}
+		}
+	}
+}
+
+write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg, collection: ^Collection) {
 	fmt.wprintln(w, `<div class="row odin-main">`)
 	defer fmt.wprintln(w, `</div>`)
 
-	fmt.wprintln(w, `<article class="col-lg-9 p-4 documentation odin-article">`)
+	write_pkg_sidebar(w, pkg, collection)
 
-	{ // breadcrumbs
+	fmt.wprintln(w, `<article class="col-lg-8 p-4 documentation odin-article">`)
+
+	if false { // breadcrumbs
 		fmt.wprintln(w, `<div class="row">`)
 		defer fmt.wprintln(w, `</div>`)
 
@@ -1017,7 +1136,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		io.write_string(w, "<ol class=\"breadcrumb\">\n")
 		defer io.write_string(w, "</ol>\n")
 
-		fmt.wprintf(w, `<li class="breadcrumb-item"><a class="breadcrumb-link" href="%s">core</a></li>`, BASE_CORE_URL)
+		fmt.wprintf(w, `<li class="breadcrumb-item"><a class="breadcrumb-link" href="%s">core</a></li>`, collection.base_url)
 
 		dirs := strings.split(path, "/")
 		for dir, i in dirs {
@@ -1032,8 +1151,8 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 				io.write_string(w, `<li class="breadcrumb-item">`)
 			}
 
-			if !is_curr && (short_path in pkgs_to_use) {
-				fmt.wprintf(w, `<a href="%s/%s">%s</a>`, BASE_CORE_URL, url, dir)
+			if !is_curr && (short_path in collection.pkgs_to_use) {
+				fmt.wprintf(w, `<a href="%s/%s">%s</a>`, collection.base_url, url, dir)
 			} else {
 				io.write_string(w, dir)
 			}
@@ -1148,6 +1267,8 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			pkg = pkg_index,
 		}
 		defer delete(writer.generic_scope)
+		collection := pkg_to_collection[pkg]
+		github_url := collection.github_url if collection != nil else GITHUB_CORE_URL
 
 		name := str(e.name)
 		path := pkg_to_path[pkg]
@@ -1155,7 +1276,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 		fmt.wprintf(w, "<h3 id=\"{0:s}\"><span><a class=\"doc-id-link\" href=\"#{0:s}\">{0:s}", name)
 		fmt.wprintf(w, "<span class=\"a-hidden\">&nbsp;¶</span></a></span>")
 		if e.pos.file != 0 && e.pos.line > 0 {
-			src_url := fmt.tprintf("%s/%s/%s#L%d", GITHUB_CORE_URL, path, filename, e.pos.line)
+			src_url := fmt.tprintf("%s/%s/%s#L%d", github_url, path, filename, e.pos.line)
 			fmt.wprintf(w, "<div class=\"doc-source\"><a href=\"{0:s}\"><em>Source</em></a></div>", src_url)
 		}
 		fmt.wprintf(w, "</h3>\n")
@@ -1240,8 +1361,10 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 				if this_pkg != pkg_index {
 					fmt.wprintf(w, "%s.", str(pkgs[this_pkg].name))
 				}
+				pkg := &pkgs[this_pkg]
+				collection := pkg_to_collection[pkg]
 				name := str(this_proc.name)
-				fmt.wprintf(w, `<a class="code-procedure" href="{2:s}/{0:s}/#{1:s}">`, pkg_to_path[&pkgs[this_pkg]], name, BASE_CORE_URL)
+				fmt.wprintf(w, `<a class="code-procedure" href="{2:s}/{0:s}/#{1:s}">`, pkg_to_path[pkg], name, collection.base_url)
 				io.write_string(w, name)
 				io.write_string(w, `</a>`)
 				io.write_byte(w, ',')
@@ -1305,7 +1428,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			any_hidden = true
 			continue source_file_loop
 		}
-		fmt.wprintf(w, `<li><a href="%s/%s/%s">%s</a></li>`, GITHUB_CORE_URL, path, filename, filename)
+		fmt.wprintf(w, `<li><a href="%s/%s/%s">%s</a></li>`, collection.github_url, path, filename, filename)
 		fmt.wprintln(w)
 	}
 	if any_hidden {
@@ -1313,6 +1436,13 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 	}
 	fmt.wprintln(w, "</ul>")
 
+	{
+		fmt.wprintln(w, `<h2 id="pkg-generation-information">Generation Information</h2>`)
+		now := time.now()
+		fmt.wprintf(w, "<p>Generated with <code>odin version %s (vendor %q) %s_%s @ %v</code></p>\n", ODIN_VERSION, ODIN_VENDOR, ODIN_OS, ODIN_ARCH, now)
+	}
+
+
 
 	fmt.wprintln(w, `</article>`)
 	{
@@ -1320,7 +1450,7 @@ write_pkg :: proc(w: io.Writer, path: string, pkg: ^doc.Pkg) {
 			fmt.wprintf(w, `<li><a href="#%s">%s</a>`, id, text)
 		}
 
-		fmt.wprintln(w, `<div class="col-lg-3 odin-toc-border navbar-light"><div class="sticky-top odin-below-navbar py-3">`)
+		fmt.wprintln(w, `<div class="col-lg-2 odin-toc-border navbar-light"><div class="sticky-top odin-below-navbar py-3">`)
 		fmt.wprintln(w, `<nav id="TableOfContents">`)
 		fmt.wprintln(w, `<ul>`)
 		if overview_docs != "" {
diff --git a/tools/odin-html-docs/style.css b/tools/odin-html-docs/style.css
index cb06a8603..13db2f3c2 100644
--- a/tools/odin-html-docs/style.css
+++ b/tools/odin-html-docs/style.css
@@ -76,6 +76,7 @@ pre.doc-code a.code-procedure {
 
 .pkg-line-doc {
 	color: #444;
+	width: 100%;
 }
 
 
@@ -115,9 +116,7 @@ section.documentation h3 {
 }
 
 details.doc-index > summary {
-	position: relative;
 	font-size: 1.75rem;
-	left: -1.75rem;
 }
 details.doc-index ul {
 	list-style-type: none;
@@ -138,3 +137,27 @@ details.odin-doc-toggle[open] > summary.hideme {
 details.code-example > summary {
 	font-weight: 700;
 }
+
+@media only screen and (max-width: 991px) {
+	#pkg-sidebar {
+		display: none;
+	}
+}
+
+#pkg-sidebar ul {
+	list-style-type: none;
+	padding: 0;
+}
+
+#pkg-sidebar li:not(:last-child) {
+	margin-bottom: 0.25rem;
+}
+
+
+#pkg-sidebar li > ul {
+	padding-left: 1.25rem;
+}
+
+#pkg-sidebar a.active {
+	font-style: italic;
+}
\ No newline at end of file

From 4dc5839e3d08305b5b050c433cd9e518df175685 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 22 Jan 2022 17:09:10 +0000
Subject: [PATCH 31/37] Add header-lower.txt.html

---
 tools/odin-html-docs/header-lower.txt.html | 36 ++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 tools/odin-html-docs/header-lower.txt.html

diff --git a/tools/odin-html-docs/header-lower.txt.html b/tools/odin-html-docs/header-lower.txt.html
new file mode 100644
index 000000000..25ef7b7de
--- /dev/null
+++ b/tools/odin-html-docs/header-lower.txt.html
@@ -0,0 +1,36 @@
+	<!-- REMEMBER TO REMOVE -->
+	<script type="text/javascript" src="https://livejs.com/live.js"></script>
+
+	<link rel="stylesheet" type="text/css" href="https://odin-lang.org/scss/custom.min.css">
+	<link rel=stylesheet href=//odin-lang.org/lib/highlight/styles/github-dark.min.css>
+	<script src=//odin-lang.org/lib/highlight/highlight.min.js></script>
+	<script>hljs.registerLanguage("odin",function(a){return{aliases:["odin","odinlang","odin-lang"],keywords:{keyword:"auto_cast bit_set break case cast context continue defer distinct do dynamic else enum fallthrough for foreign if import in map not_in or_else or_return package proc return struct switch transmute type_of typeid union using when where",literal:"true false nil",built_in:"abs align_of cap clamp complex conj expand_to_tuple imag jmag kmag len max min offset_of quaternion real size_of soa_unzip soa_zip swizzle type_info_of type_of typeid_of"},illegal:"</",contains:[a.C_LINE_COMMENT_MODE,a.C_BLOCK_COMMENT_MODE,{className:"string",variants:[a.QUOTE_STRING_MODE,{begin:"'",end:"[^\\\\]'"},{begin:"`",end:"`"}]},{className:"number",variants:[{begin:a.C_NUMBER_RE+"[ijk]",relevance:1},a.C_NUMBER_MODE]}]}})</script>
+	<script>hljs.highlightAll()</script>
+	<link rel="stylesheet" type="text/css" href="https://odin-lang.org/css/style.css">
+
+	<link rel="stylesheet" type="text/css" href="/style.css">
+
+	</style>
+</head>
+<body>
+<header class="sticky-top">
+	<nav class="navbar navbar-expand-lg navbar-dark bg-primary odin-menu">
+		<div class="container">
+			<a class="navbar-brand" href="/">
+			<img src="https://odin-lang.org/logo.svg" height="30" alt="Odin"></a>
+			<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#odin-navbar-content" aria-controls="odin-navbar-content" aria-expanded="false" aria-label="Toggle navigation"><span class="navbar-toggler-icon"></span></button>
+			<div class="collapse navbar-collapse" id="odin-navbar-content">
+			<ul class="navbar-nav ms-md-auto">
+				<li class="nav-item"><a class="nav-link" href="https://odin-lang.org/">Home</a></li>
+				<li class="nav-item"><a class="nav-link" href="https://odin-lang.org/docs">Docs</a></li>
+				<li class="nav-item"><a class="nav-link active" href="/">Packages</a></li>
+				<li class="nav-item"><a class="nav-link" href="https://odin-lang.org/news">News</a></li>
+				<li class="nav-item"><a class="nav-link" href="https://odin-lang.org/community">Community</a></li>
+				<li class="nav-item"><a class="nav-link" href="https://github.com/odin-lang/Odin" target="_blank">GitHub</a></li>
+			</ul>
+		</div>
+		</div>
+	</nav>
+</header>
+<main>
+<div class="container">
\ No newline at end of file

From 9c1e1a63a2f2e9a176b8029e742cb07617d06ad2 Mon Sep 17 00:00:00 2001
From: Platin21 <arminmops@icloud.com>
Date: Sat, 22 Jan 2022 20:29:57 +0100
Subject: [PATCH 32/37] Added pattern function so we can match whatever llvm
 versions we want

Right now we match every version that is 13 something for arm64 on macOS
And for x86 we allow any above 11 and including 11
---
 Makefile | 38 +++++++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/Makefile b/Makefile
index 6acecccc4..e6198a954 100644
--- a/Makefile
+++ b/Makefile
@@ -8,25 +8,33 @@ CC=clang
 OS=$(shell uname)
 
 ifeq ($(OS), Darwin)
+    
     ARCH=$(shell uname -m)
-    LLVM_CONFIG=llvm-config
+    LLVM_CONFIG=
 
+    # allow for arm only llvm's with version 13
     ifeq ($(ARCH), arm64)
-        ifneq ($(shell llvm-config --version | grep "^13\."),)
-            LLVM_CONFIG=llvm-config
-        else
-            $(error "Requirement: llvm-config must be version llvm 13 for arm64")
-        endif
+        LLVM_VERSIONS = "13.%.%"
     else
-        ifneq ($(shell llvm-config --version | grep "^11\."),)
-            LLVM_CONFIG=llvm-config
-        else ifneq ($(shell llvm-config --version | grep "^12\."),)
-            LLVM_CONFIG=llvm-config
-        else ifneq ($(shell llvm-config --version | grep "^13\."),)
-            LLVM_CONFIG=llvm-config
-        else
-            $(error "Requirement: llvm-config must be version llvm 11 or 12 or 13 for amd64/x86")
-        endif
+    # allow for x86 / amd64 all llvm versions begining from 11
+        LLVM_VERSIONS = "13.%.%" "12.0.1" "11.1.0" "11.0.1" "11.0.0"
+    endif
+
+    LLVM_VERSION_PATTERN_SEPERATOR = )|(
+    LLVM_VERSION_PATTERNS_ESCAPED_DOT = $(subst .,\.,$(LLVM_VERSIONS))
+    LLVM_VERSION_PATTERNS_REPLACE_PERCENT = $(subst %,.,$(LLVM_VERSION_PATTERNS_ESCAPED_DOT))
+    LLVM_VERSION_PATTERN_REMOVE_ELEMENTS = $(subst " ",$(LLVM_VERSION_PATTERN_SEPERATOR),$(LLVM_VERSION_PATTERNS_REPLACE_PERCENT))
+    LLMV_VERSION_PATTERN_REMOVE_SINGLE_STR = $(subst ",,$(LLVM_VERSION_PATTERN_REMOVE_ELEMENTS))
+    LLVM_VERSION_PATTERN = "^(($(LLMV_VERSION_PATTERN_REMOVE_SINGLE_STR)))"
+
+    ifneq ($(shell llvm-config --version | grep -E $(LLVM_VERSION_PATTERN)),)
+        LLVM_CONFIG=llvm-config
+    else
+        ifeq ($(ARCH), arm64)
+            $(error "Requirement: llvm-config must be base version 13 for arm64")
+        else 
+            $(error "Requirement: llvm-config must be base version greater than 11 for amd64/x86")
+        endif 
     endif 
 
     LDFLAGS:=$(LDFLAGS) -liconv

From f9265c14bf5ea7b9d53a5d7356af2a7c3b47e2e2 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 22 Jan 2022 19:37:35 +0000
Subject: [PATCH 33/37] Update footer.txt.html

---
 tools/odin-html-docs/footer.txt.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/odin-html-docs/footer.txt.html b/tools/odin-html-docs/footer.txt.html
index 548a00995..ad73d2834 100644
--- a/tools/odin-html-docs/footer.txt.html
+++ b/tools/odin-html-docs/footer.txt.html
@@ -15,7 +15,8 @@
 			<h4 class="fw-normal">Resources</h4>
 			<ul class="list-unstyled">
 			<li><a href="https://odin-lang.org/docs" class="link-light">Docs</a></li>
-			<li><a href="https://odin-lang.org/news" class="link-light">Blog</a></li>
+			<li><a href="https://pkg.odin-lang.org/" class="link-light">Packages</a></li>
+			<li><a href="https://odin-lang.org/news" class="link-light">News</a></li>
 			</ul>
 		</nav>
 		<nav class="col-md-auto">

From 9bc5b84c4de848a49ead8142b9f261eb053c63fa Mon Sep 17 00:00:00 2001
From: Platin21 <arminmops@icloud.com>
Date: Sat, 22 Jan 2022 20:40:04 +0100
Subject: [PATCH 34/37] Removes maybe unsupported versions

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index e6198a954..86762af6c 100644
--- a/Makefile
+++ b/Makefile
@@ -17,7 +17,7 @@ ifeq ($(OS), Darwin)
         LLVM_VERSIONS = "13.%.%"
     else
     # allow for x86 / amd64 all llvm versions begining from 11
-        LLVM_VERSIONS = "13.%.%" "12.0.1" "11.1.0" "11.0.1" "11.0.0"
+        LLVM_VERSIONS = "13.%.%" "12.0.1" "11.1.0"
     endif
 
     LLVM_VERSION_PATTERN_SEPERATOR = )|(

From 59f3a009fa24afaa194b4092742d2ea7b4c9362a Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 22 Jan 2022 19:46:22 +0000
Subject: [PATCH 35/37] Update header-lower.txt.html

---
 tools/odin-html-docs/header-lower.txt.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/odin-html-docs/header-lower.txt.html b/tools/odin-html-docs/header-lower.txt.html
index 25ef7b7de..ae5dec861 100644
--- a/tools/odin-html-docs/header-lower.txt.html
+++ b/tools/odin-html-docs/header-lower.txt.html
@@ -16,7 +16,7 @@
 <header class="sticky-top">
 	<nav class="navbar navbar-expand-lg navbar-dark bg-primary odin-menu">
 		<div class="container">
-			<a class="navbar-brand" href="/">
+			<a class="navbar-brand" href="https://odin-lang.org/">
 			<img src="https://odin-lang.org/logo.svg" height="30" alt="Odin"></a>
 			<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#odin-navbar-content" aria-controls="odin-navbar-content" aria-expanded="false" aria-label="Toggle navigation"><span class="navbar-toggler-icon"></span></button>
 			<div class="collapse navbar-collapse" id="odin-navbar-content">

From b3c3e41706ad19c1be86ba1b15d5c26c46d30b4f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 22 Jan 2022 19:49:46 +0000
Subject: [PATCH 36/37] Correct directory comment printing

---
 tools/odin-html-docs/odin_html_docs_main.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/odin-html-docs/odin_html_docs_main.odin b/tools/odin-html-docs/odin_html_docs_main.odin
index e5d46547a..ec5103363 100644
--- a/tools/odin-html-docs/odin_html_docs_main.odin
+++ b/tools/odin-html-docs/odin_html_docs_main.odin
@@ -481,7 +481,7 @@ write_collection_directory :: proc(w: io.Writer, collection: ^Collection) {
 			line_doc, _, _ := strings.partition(str(child.pkg.docs), "\n")
 			line_doc = strings.trim_space(line_doc)
 			io.write_string(w, `<td class="pkg-line pkg-line-doc">`)
-			if line_doc, ok := get_line_doc(dir.pkg); ok {
+			if line_doc, ok := get_line_doc(child.pkg); ok {
 				write_doc_line(w, line_doc)
 			} else {
 				io.write_string(w, `&nbsp;`)

From 8516e2e7e35ee68e7dab9b03f54be7e906bdb251 Mon Sep 17 00:00:00 2001
From: Platin21 <arminmops@icloud.com>
Date: Sat, 22 Jan 2022 20:50:05 +0100
Subject: [PATCH 37/37] Changed match to be arbitrary width

(cant do exact match as we never know how much subversion's llvm does)
---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 86762af6c..d3d3c6a2d 100644
--- a/Makefile
+++ b/Makefile
@@ -22,7 +22,7 @@ ifeq ($(OS), Darwin)
 
     LLVM_VERSION_PATTERN_SEPERATOR = )|(
     LLVM_VERSION_PATTERNS_ESCAPED_DOT = $(subst .,\.,$(LLVM_VERSIONS))
-    LLVM_VERSION_PATTERNS_REPLACE_PERCENT = $(subst %,.,$(LLVM_VERSION_PATTERNS_ESCAPED_DOT))
+    LLVM_VERSION_PATTERNS_REPLACE_PERCENT = $(subst %,.*,$(LLVM_VERSION_PATTERNS_ESCAPED_DOT))
     LLVM_VERSION_PATTERN_REMOVE_ELEMENTS = $(subst " ",$(LLVM_VERSION_PATTERN_SEPERATOR),$(LLVM_VERSION_PATTERNS_REPLACE_PERCENT))
     LLMV_VERSION_PATTERN_REMOVE_SINGLE_STR = $(subst ",,$(LLVM_VERSION_PATTERN_REMOVE_ELEMENTS))
     LLVM_VERSION_PATTERN = "^(($(LLMV_VERSION_PATTERN_REMOVE_SINGLE_STR)))"