Package engineapi provides libraries to implement client and server components compatible with the Docker engine.
Fluux XMPP is an modern and full-featured XMPP library that can be used to build clients or server components.
Package daz is a library for building composable HTML components in Go.
Package myui is a component library for MyGo native UI (package ui): design tokens, theme presets, styled variants of built-in widgets, and composite desktop components such as pages, overlays and AI chat views that MyGo does not ship.
Package engineapi provides libraries to implement client and server components compatible with the Docker engine.
Package auth contains the authentication and authorization benchmarks that live outside the component module, so github.com/shibingli/ydx/auth never depends on benchmark-only code or comparison libraries.
Package json contains the JSON benchmarks that live outside the component module, so github.com/shibingli/ydx/json never depends on benchmark-only code or comparison libraries.
Package base64 contains the Base64 benchmarks that live outside the component module, so github.com/shibingli/ydx/base64 never depends on benchmark-only code or third-party comparison libraries.
Package log contains the logging benchmarks that live outside the component module, so github.com/shibingli/ydx/log never depends on benchmark-only code or comparison libraries.
Package jwt contains the JWT benchmarks that live outside the component module, so github.com/shibingli/ydx/auth/token/jwt never depends on benchmark-only code or comparison libraries.
Package aztables can access an Azure Storage or CosmosDB account. The aztables package is capable of: The Azure Data Tables library allows you to interact with two types of resources: * the tables in your account * the entities within those tables. Interaction with these resources starts with an instance of a client. To create a client object, you will need the account's table service endpoint URL and a credential that allows you to access the account. The clients support different forms of authentication. The aztables library supports any of the `azcore.TokenCredential` interfaces, authorization via a Connection String, or authorization with a Shared Access Signature token. To use an account shared key (aka account key or access key), provide the key as a string. This can be found in your storage account in the Azure Portal under the "Access Keys" section. Use the key as the credential parameter to authenticate the client: Using a Connection String Depending on your use case and authorization method, you may prefer to initialize a client instance with a connection string instead of providing the account URL and credential separately. To do this, pass the connection string to the client's `from_connection_string` class method. The connection string can be found in your storage account in the [Azure Portal][azure_portal_account_url] under the "Access Keys" section or with the following Azure CLI command: Using a Shared Access Signature To use a shared access signature (SAS) token, provide the token at the end of your service URL. You can generate a SAS token from the Azure Portal under Shared Access Signature or use the ServiceClient.GetAccountSASToken or Client.GetTableSASToken() functions. Common uses of the Table service included: * Storing TBs of structured data capable of serving web scale applications * Storing datasets that do not require complex joins, foreign keys, or stored procedures and can be de-normalized for fast access * Quickly querying data using a clustered index * Accessing data using the OData protocol and LINQ filter expressions The following components make up the Azure Data Tables Service: * The account * A table within the account, which contains a set of entities * An entity within a table, as a dictionary The Azure Data Tables client library for Go allows you to interact with each of these components through the use of a dedicated client object. Two different clients are provided to interact with the various components of the Table Service: 1. **`ServiceClient`** - 2. **`Client`** - Entities are similar to rows. An entity has a PartitionKey, a RowKey, and a set of properties. A property is a name value pair, similar to a column. Every entity in a table does not need to have the same properties. Entities are returned as JSON, allowing developers to use JSON marshalling and unmarshalling techniques. Additionally, you can use the aztables.EDMEntity to ensure proper round-trip serialization of all properties. The following sections provide several code snippets covering some of the most common Table tasks, including: * Creating a table * Creating entities * Querying entities Create a table in your account and get a `Client` to perform operations on the newly created table: Creating Entities Querying entities
Package ui is a reusable Go templ + HTMX UI library: the "paper and highlighter" design system (GNOME HIG-inspired), its static assets (CSS, fonts, htmx, ui.js), templ components and the server-side services that pair with them (toasts, modals, confirm, CSRF, form errors).
Package tuiweave is a composable component library for building custom terminal UIs on bubbletea v2 and lipgloss v2, designed so that humans and coding agents can reliably compose and evolve complete frontends with it.
Package pitypesafe is the typed API of Pigpen's TypeSafe integration: a Go port of the library half of pi-typesafe (https://github.com/DevMortimer/pi-typesafe, MIT, Ryan Gapac).
Package goui is a templ + Tailwind v4 + Alpine.js component library, ported from BlatUI.
Package kvitui is the Kvit component library for desktop applications drawn with unison: the components that give every Kvit app the same look and behaviour, built from the design values in the tokens package.
Package-internal image comparison built on pixelmatch (the same perceptual diff library chromedp's own test suite uses).
donburi is an Entity Component System library for Go/Ebitengine inspired by legion.
Package slixmppgo is a Go-native XMPP client, component, XEP, and OMEMO integration library inspired by the public APIs of Slixmpp and slixmpp-omemo.
Extensible Go library for creating fast, SSR-first frontend avoiding vanilla templating downsides. Creating asynchronous and dynamic layout parts is a complex problem for larger projects using `html/template`. Library tries to simplify this process. Let's go straight into a simple example. Then, we will dig into details, step by step, how it works. Kyoto provides a simple net/http handlers and function wrappers to handle pages rendering and serving. See functions inside of nethttp.go file for details and advanced usage. Example: Kyoto provides a way to define components. It's a very common approach for modern libraries to manage frontend parts. In kyoto each component is a context receiver, which returns it's state. Each component becomes a part of the page or top-level component, which executes component asynchronously and gets a state future object. In that way your components are executing in a non-blocking way. Pages are just top-level components, where you can configure rendering and page related stuff. Example: As an option, you can wrap component with another function to accept additional paramenters from top-level page/component. Example: Kyoto provides a context, which holds common objects like http.ResponseWriter, *http.Request, etc. See kyoto.Context for details. Example: Kyoto provides a set of parameters and functions to provide a comfortable template building process. You can configure template building parameters with kyoto.TemplateConf configuration. See template.go for available functions and kyoto.TemplateConfiguration for configuration details. Example: Kyoto provides a way to simplify building dynamic UIs. For this purpose it has a feature named actions. Logic is pretty simple. Client calls an action (sends a request to the server). Action is executing on server side and server is sending updated component markup to the client which will be morphed into DOM. That's it. To use actions, you need to go through a few steps. You'll need to include a client into page (JS functions for communication) and register an actions handler for a needed component. Let's start from including a client. Then, let's register an actions handler for a needed component. That's all! Now we ready to use actions to provide a dynamic UI. Example: In this example you can see provided modifications to the quick start example. First, we've added a state and name into our components' markup. In this way we are saving our components' state between actions and find a component root. Unfortunately, we have to manually provide a component name for now, we haven't found a way to provide it dynamically. Second, we've added a reload button with onclick function call. We're using a function Action provided by a client. Action triggering will be described in details later. Third, we've added an action handler inside of our component. This handler will be executed when a client calls an action with a corresponding name. It's highly recommended to keep components' state as small as possible. It will be transmitted on each action call. Kyoto have multiple ways to trigger actions. Now we will check them one by one. This is the simplest way to trigger an action. It's just a function call with a referer (usually 'this', f.e. button) as a first argument (used to determine root), action name as a second argument and arguments as a rest. Arguments must to be JSON serializable. It's possible to trigger an action of another component. If you want to call an action of parent component, use $ prefix in action name. If you want to call an action of component by id, use <id:action> as an action name. This is a specific action which is triggered when a form is submitted. Usually called in onsubmit="..." attribute of a form. You'll need to implement 'Submit' action to handle this trigger. This is a special HTML attribute which will trigger an action on page load. This may be useful for components' lazy loading. With this special HTML attributes you can trigger an action with interval. Useful for components that must to be updated over time (f.e. charts, stats, etc). You can use this trigger with ssa:poll and ssa:poll.interval HTML attributes. This one attribute allows you to trigger an action when an element is visible on the screen. May be useful for lazy loading. Kyoto provides a way to control action flow. For now, it's possible to control display style on component call and push multiple UI updates to the client during a single action. Because kyoto makes a roundtrip to the server every time an action is triggered on the page, there are cases where the page may not react immediately to a user event (like a click). That's why the library provides a way to easily control display attributes on action call. You can use this HTML attribute to control display during action call. At the end of an action the layout will be restored. A small note. Don't forget to set a default display for loading elements like spinners and loaders. You can push multiple component UI updates during a single action call. Just call kyoto.ActionFlush(ctx, state) to initiate an update. Kyoto provides a way to control action rendering. Now there is at least 2 rendering options after an action call: morph (default) and replace. Morph will try to morph received markup to the current one with morphdom library. In case of an error, or explicit "replace" mode, markup will be replaced with x.outerHTML = '...'.
Package lumberjack provides a rolling logger. Note that this is v2.0 of lumberjack, and should be imported using gopkg.in thusly: The package name remains simply lumberjack, and the code resides at https://github.com/natefinch/lumberjack under the v2.0 branch. Lumberjack is intended to be one part of a logging infrastructure. It is not an all-in-one solution, but instead is a pluggable component at the bottom of the logging stack that simply controls the files to which logs are written. Lumberjack plays well with any logging package that can write to an io.Writer, including the standard library's log package. Lumberjack assumes that only one process is writing to the output files. Using the same lumberjack configuration from multiple processes on the same machine will result in improper behavior. To use lumberjack with the standard library's log package, just pass it into the SetOutput function when your application starts.
Package lumberjack provides a rolling logger. Note that this is v3.0 of lumberjack. Lumberjack is intended to be one part of a logging infrastructure. It is not an all-in-one solution, but instead is a pluggable component at the bottom of the logging stack that simply controls the files to which logs are written. Lumberjack plays well with any logging package that can write to an io.Writer, including the standard library's log package. Lumberjack assumes that only one process is writing to the output files. Using the same lumberjack configuration from multiple processes on the same machine will result in improper behavior. Letting outside processes write to or manipulate the file that lumberjack writes to will also result in improper behavior. To use lumberjack with the standard library's log package, just pass it into the SetOutput function when your application starts.
Package loq provides components for use with Go's log/slog library, intended to make logs easy to write and easier to read.
Package tuiweave is a composable component library for building custom terminal UIs on bubbletea v2 and lipgloss v2, designed so that humans and coding agents can reliably compose and evolve complete frontends with it.
Package engineapi provides libraries to implement client and server components compatible with the Docker engine.
Package tuicomponents is the root package for the tui-components library.
Package blit is a pragmatic TUI toolkit for shipping Go CLI tools fast. It wraps Bubble Tea and Lip Gloss with reusable components (Table, ListView, Tabs, Picker, Form, Tree, LogViewer), a layout engine (DualPane, HBox, VBox, Split), a keybinding registry with auto-generated help, a dark/light theme system with hot-reload, and built-in binary self-update. Quick start: See https://blitui.github.io/blit/ for guides and examples. Package blit provides TUI components and update utilities. Cosign signature verification — implementation notes: We deliberately avoid the full sigstore/cosign library (github.com/sigstore/cosign) because it pulls in hundreds of transitive dependencies (OCI registry clients, Fulcio/Rekor TLS stacks, OIDC flows) that would bloat every consumer binary. Instead we implement the narrow subset that covers the common offline case: a detached ed25519 signature over the raw asset bytes, stored as a <asset>.sig release attachment and signed with `cosign sign-blob --key <ed25519.key>`. The corresponding public key (PEM or bare base64) is embedded in UpdateConfig. If CosignPublicKey is empty the verification step is skipped entirely, keeping the feature strictly opt-in and zero-cost for existing consumers.
Package engineapi provides libraries to implement client and server components compatible with the Docker engine.
Package teautils provides shared utilities for the go-tealeaves component library: a key registry with help generation, overlay positioning, styled rendering helpers, and a theming system (palette, theme, teacolor).
Package logslibrary provides the logs library component bundle