DEV Community: Alexandr Zahatski

Podlite Desktop 0.7.0 — smart lists, code folding

Alexandr Zahatski — Mon, 30 Mar 2026 16:59:08 +0000

Podlite Desktop 0.7.0 is out. A free, open source editor for Podlite markup — a block-based language that extends Markdown with diagrams, formulas, tables and task lists.

What's new in 0.7.0

smart list continuation on Enter with checkbox/numbering inheritance
Tab / Shift+Tab for nesting levels
code folding for =begin/=end and =head sections
collapsible blocks via :folded attribute
input latency reduced from 860ms to near-zero
session restore (cursor, scroll, folds, view mode)

Available on macOS, Windows, Linux.

Download from GitHub · Mac App Store · Microsoft Store · Snap Store

Site: podlite.org

One command to add structured markup to your AI agent

Alexandr Zahatski — Wed, 11 Mar 2026 21:41:26 +0000

I've been keeping a personal knowledge base for years. Notes, specs, decisions, journal entries — all in plain text files. When AI agents became part of my workflow, I started using them to write structured documents: RFC drafts, revision histories, typed notes with metadata. It worked well. Until I closed the session.

The next agent would open the same file and start from scratch — not because it forgot, but because the file gave no structure to hold onto. That's when I started looking at the format, not the model.

The problem I kept running into

My knowledge base has hundreds of files. An agent can read them, but reading isn't the same as understanding the shape of the file. Is this a journal entry or a spec? Is this draft published or scheduled? When was it written?

Plain text doesn't answer those questions. Markdown frontmatter gets you partway — but it's a convention, not a contract. Tools may or may not parse it, and agents that haven't been told what to look for usually don't. When I asked an agent to "write a blog post and schedule it for next Thursday," it produced great prose and put a date somewhere in the text. My publishing pipeline saw nothing.

The problem wasn't the agent's writing. The problem was that the file had no machine-readable structure. The agent had nowhere to put the metadata so that both humans and downstream tools could reliably find it.

What Podlite gives you

Podlite is a markup language built around explicit, typed blocks. Every block has a declared type, and blocks can carry named attributes — structured metadata that travels with the content.

Here's what a blog post looks like when an agent creates it:

=begin pod :pubdate('2026-03-12 10:00:00') :type('page') :publishUrl('/blog/podlite-skills')

=TITLE One command to add structured markup to your AI agent

Content written by the agent...

=end pod

The :pubdate, :type, and :publishUrl attributes aren't decorative. They're fields — any parser or tool that reads Podlite can access them directly, without guessing where in the prose to look.

Podlite natively includes Markdown, so you don't throw away existing files or habits. You can use Markdown syntax inside Podlite blocks without any changes. The structure layer sits on top; the content layer stays familiar.

How this plays out in practice

I ask Claude Code to draft a blog post about a recent technical decision. It creates a .podlite file with :pubdate set to next Wednesday and :publishUrl matching the slug I described. The prose is good. The metadata is correct. I close the session.

On Tuesday, I open a new session and ask a different agent to review the post and push the publish date back a week — I want more time to add a code example. The agent opens the file, reads the block header, finds :pubdate, changes the timestamp. That's it.

Worth slowing down on: the second agent didn't need context from the first session. The file itself carried the instructions. :pubdate is not a comment or a prose sentence — it's a structured field that any agent, parser, or tool can read without guessing. What acts on it depends on your setup — in my case a publishing pipeline that scans the folder and schedules based on the attribute. But the attribute is readable by anything.

This is the difference between "metadata mentioned in the file" and "metadata in the file."

Installing podlite-skills

npx skills add podlite/podlite-skills

This adds Podlite support to your AI agent environment — Claude Code, GitHub Copilot, Cursor, Codex CLI. After installation, the agent understands Podlite block syntax, attribute conventions, and how to create well-formed structured documents.

No configuration file to edit. No extension to install separately. The skill installs, and the agent knows the format. Even without a custom pipeline, you get files where an agent consistently puts type information and metadata in the same place — which means the next agent (or the next you, in six months) can read the file and know exactly what it is and what state it's in.

What I actually use it for

Three categories got noticeably better after switching:

Blog posts and RFC drafts — :pubdate, :status, :type mean any agent can pick up where another left off without me re-explaining the document's state.

Decision logs — typed blocks mean I can query "all decisions made in Q1" without parsing prose.

Specs with revision history — explicit block structure makes diff-reading much easier for agents doing review passes.

The files are still plain text. The agent still writes prose. The difference is that now the output holds its shape between sessions — metadata stays where it was put, structure stays parseable, and any tool or agent that opens the file later starts with something to work with rather than nothing.

If you're already using an AI agent for writing or documentation, this is a one-minute install:

npx skills add podlite/podlite-skills

The podlite-skills repository has the full list of supported blocks and attributes.

The Block Structure of Podlite

Alexandr Zahatski — Fri, 05 Dec 2025 08:14:04 +0000

Podlite is a small block-based markup language that is easy to read as plain text, simple to parse, and flexible enough to be used everywhere — in code, notes, technical documents, long-form writing, and even full documentation systems.

One of the core ideas behind Podlite is its consistent block-based structure.
Every meaningful element of a document — a heading, a paragraph, a list item, a table, a code block, a callout — is represented as a block. This makes documents both readable for humans and predictable for tools.

Podlite supports three interchangeable block styles: delimited, paragraph, and abbreviated.

Abbreviated blocks (`=BLOCK`)

This is the most compact form.
A block starts with = followed by the block name.

=head1 Getting Started
=item Install Node.js 20+
=para Podlite makes documentation predictable and easy to automate.

ends on the next directive or a blank line
best used for simple one-line blocks
cannot include configuration options (attributes)

Paragraph blocks (`=for BLOCK`)

Use this form when you want a multi-line block or need attributes.

=for code :lang<ts>
console.log("Hello from Podlite!");

ends when a blank line appears
can include complex content
allows attributes such as :lang, :id, :caption, :nested, …

Delimited blocks (`=begin BLOCK` … `=end BLOCK`)

The most expressive form. Useful for large sections, nested blocks, or structures that require clarity.

=begin nested :notify<important>
Make sure you have administrator privileges.
=end nested

explicit start and end markers
perfect for code, lists, tables, notifications, markdown, formulas
can contain other blocks, including nested ones

These block styles differ in syntax convenience, but all produce the same internal structure.

Regardless of which syntax you choose:

all three forms represent the same block type
attributes apply the same way (:lang, :caption, :id, …)
tools and renderers treat them uniformly
nested blocks work identically
you can freely mix styles inside a document

Podlite Desktop Editor 0.6.1 is out

Alexandr Zahatski — Sat, 01 Nov 2025 10:51:12 +0000

Just released a new version of Podlite Desktop Editor - a free markup editor that works with Markdown and extends it with some pretty useful features.

What's Podlite?

Think of it as Markdown++. All your standard Markdown works via =markdown blocks. It's block-oriented, so everything stays clean and readable. Check out the Podlite Quick Tour: https://podlite.org/quick-tour

What's new in 0.6.1

Rebuilt the editor from scratch with updated libraries. Here's what changed:

Syntax highlighting that actually works well
Inline formatting: B<bold>, I<italic>, C<code>, L<links>, O<strikethrough>
Click links with Cmd/Ctrl to open them
Link to other files with file: schema - they open in new windows
Text search (finally!)
Fixed a bunch of window resize bugs
macOS Tahoe support

You can toggle between half-screen and full-screen preview with keyboard shortcuts.

Download

Available free on all platforms:

Github releases: https://github.com/podlite/podlite-desktop/releases
Microsoft Store, Snap Store, Mac App Store

Try the web version first if you want: https://pod6.in

Full details: https://podlite.org/2025/11/1/1/podlite-desktop-editor-0-6-1-released

Source code: https://github.com/podlite/podlite-desktop

📝 Inline text formatting in Podlite editor

Alexandr Zahatski — Sun, 26 Oct 2025 15:30:09 +0000

Podlite supports rich inline text formatting within paragraphs and table cells:

✨ Supported Formatting Codes

Code	Description	Example	Result
`B<>`	Bold text	`B<important>`	important
`I<>`	Italic text	`I<emphasis>`	emphasis
`C<>`	`Code/monospace`	`C<function()>`	`function()`
`L<>`	🔗 Links	`L<https://example.com`\|`click here>`	click here
`O<>`	~~Strikethrough~~	`O<deleted text>`	~~deleted text~~

These formatting codes can be combined within any paragraph or table cell to create rich, formatted content.

Podlite is a lightweight block-based markup language designed for flexibility and ease of use.

Web editor with Podlite markup language syntax highlighting is here!

Alexandr Zahatski — Mon, 13 Jan 2025 17:39:25 +0000

You can check it out at pod6.in!

It was included as part of Podlite v0.0.45.

Podlite: Powering Up Knowledge Management

Alexandr Zahatski — Fri, 04 Oct 2024 06:00:00 +0000

Hey 👋 Exciting news from the Podlite project! Podlite keeps evolving, opening up new possibilities for knowledge management.

Check out this list of recent achievements in the Podlite-web package for creating web projects:

What's New? 🚀

Plugin Support: Extend functionality easily
Global Term Index & Full-Text Search: Find info fast
React Integration: Build dynamic, interactive pages
Automatic ToC & Breadcrumbs: Improve navigation
Code Syntax Highlighting: Make your docs shine

See It in Action 👀

The Raku Knowledge Base v1.0 (Artistic 2.0 License)

Check out The Raku Knowledge Base - a comprehensive, open-source knowledge base for the Raku programming language built with Podlite-web.

Raku (formerly Perl 6) is a powerful, multi-paradigm language. This knowledge base aims to make it more accessible and easier to learn.

Key Features:

📚 Official Raku documentation
📦 User module docs
💻 Code example collections
🔍 Full-text search
🧭 Easy navigation with breadcrumbs
🔗 Auto-generated term index

You can read more about the The Raku Knowledge Base in detail in the official announcement on the Podlite website podlite.org/a5ZK1.

Get Involved 🤝

🌟 Star the repo: https://github.com/zag/raku-knowledge-base
🐛 Report issues: https://github.com/zag/raku-knowledge-base/issues
🛠️ Contribute: PRs welcome!

Use Podlite for your next documentation project!
Let me know what you think or if you have any questions!

Happy coding! 💻✨
thank you!

Excited to announce that Podlite's TypeScript implementation now supports formulas! 🧮✨

Alexandr Zahatski — Mon, 27 May 2024 08:12:11 +0000

I'm excited to announce that podlite now supports formulas!

You can enter formulas using the code F<> and the block =formula.

Within the =markdown block, use $...$ for inline formulas and $$...$$ for display formulas.

Example on pod6.in

For more information, see LaTeX/Mathematics in Wikibooks.

thank you!

Podlite v1.0 released: A lightweight block-oriented markup language for organizing knowledge

Alexandr Zahatski — Tue, 23 Apr 2024 20:03:08 +0000

What is Podlite?

Podlite, a lightweight block-oriented markup language that's all about flexibility and ease of use.

Unbound by any specific domain, programming language, or concept, Podlite stands out as a universal markup language
In addition, the support for Markdown markup as a standard block adds convenience and allows for the use of familiar syntax for text formatting
It's perfect for documentation, educational materials, blogging, and much more for organizing knowledge.
One of the key features of Podlite is its extensibility. This allows for defining unique and domain-specific blocks and expanding the language's functionality according to the requirements of your project.
The Podlite specification is published under the Artistic license 2.0.

Key Features of Podlite

Block-based structure: At the core of Podlite is the concept of "blocks," which are the fundamental units of any document. These blocks can have defined attributes and support the inclusion of rich content.
Rich linking capabilities: Podlite allows blocks, terms, definitions to be linked with various types of relationships, enhancing the interconnectivity and navigability of your documents.
Support for formulas and Markdown: Whether you need to insert complex mathematical formulas or prefer the simplicity of Markdown, Podlite has you covered. It seamlessly integrates both, giving you the flexibility to choose how you want to write.
Extensible and customizable: Extend Podlite with custom blocks and inline codes, tailoring the language to meet your specific needs.

Podlite v1.0 Release Notes

Podlite has introduced a range of new features designed to enhance the flexibility and usability of the markup language:

Customization and Extensibility

Refactoring of Custom blocks: Enhanced customization through refactored named custom blocks.
Inline Markup extension: M<> now extends inline markup features, allowing for more expressive text formatting.

Processing and data handling

Markdown support: The `=markdown block is now a standard block. Integration of a new markdown mode for the parser.
MIME type specification: Added :mime-type attribute for =include and =data blocks, facilitating better handling of diverse data types.
Data schema introduction: Implemented data: schema for use in =picture and =table blocks, simplifying data embedding.
Embedding binary data: Support for embedding binary data directly into documents with :filename and :encoding attributes in =data blocks.
CSV tables: Capability to render tables directly from CSV files with the enhanced =table block.

Content Structuring and Navigation

Selectors: Introduced selectors for dynamic content interaction and manipulation.
Comprehensive TOC: Enhanced =toc block for generating detailed tables of contents.
Including external content: New =include block for incorporating external files and documents seamlessly.
Advanced table formatting: New =row and =cell blocks with :header, :rowspan, and :colspan attributes for intricate table designs.
Additional attributes for linking: Addition of :id, :caption, and :lang attributes to enrich document metadata and accessibility.
Contextual backlinks: W<> for creating contextual backlinks, enhancing document navigation and reference capabilities.
Foldable content: New :folded attribute to toggle visibility of content, and :folded-levels for nested visibility control in table of contents (TOC) blocks.

Document Presentation Enhancements

Notification blocks: Introduced notification blocks with a :notify attribute, improving interactivity within documents.
Task lists: Introduction of task lists with the =item block and a :checked attribute to manage to-do items effectively.
Mistake marking: Introduced O<> for highlighting and marking mistakes, useful in educational and review settings.
Text positioning: New attributes J<> for justifying and H<> for horizontal positioning of text.
Emojis: Added support for emojis with E<>, enriching the expressiveness of documents.
Picture insertions: New features in the =picture block and P<> for improved image handling.
Mathematical formulas: Enhanced support for complex mathematical formulas with =formula and F<>.

Deprecated/removed

With the introduction of new functionalities, certain features have been deprecated or removed to streamline Podlite:

P<toc:> due to =toc block,
P<man:>, P<doc:> due to =include block,
:margin attribute, =encoding directive, Declarator block been removed due to redundancy.
Contextual aliases, the =finish directive, and markers in comments, P<> - placement links, :formatted attribute, :like attribute have been removed due to redundancy and enhancements in other areas.

Summary of Release

This release of Podlite introduces significant enhancements aimed at improving the flexibility, customization, and user interaction of the markup language. With the addition of new blocks, attributes, and support for rich media, Podlite is better equipped to handle a variety of documentation needs.

Concurrently, the deprecation and removal of certain features have simplified the toolset, reducing overlap and enhancing user experience. These changes reflect a commitment to the continuous improvement of Podlite, ensuring it remains a versatile and powerful tool for content creators.

Feedback and Contributions

Feedback is encouraged and can be provided through Github Discussions. This input is crucial for the ongoing development and enhancement of Podlite.

Thank You!

Find out more:

Specification : https://github.com/podlite/podlite-specs, [in html format]
Website: https://podlite.org
Web playground: https://pod6.in
Github: https://github.com/podlite ⭐️

Stay tuned for more updates and happy documenting!

Introducing Podlite, a lightweight block-based markup language

Alexandr Zahatski — Wed, 21 Feb 2024 08:20:54 +0000

Hey everyone! 🚀

I'm excited to introduce a new markup language called Podlite. It's designed to make documentation, blogging, educational materials, and much more, a breeze to create and manage.

Key features of Podlite include:

Blocks as the basic unit: Each document is built from blocks, which are the basic units that can have their own defined attributes.
Flexible linking: Link blocks together in various relationships.
Formula support: Perfect for academic and scientific documentation.
Markdown support: Love Markdown? Podlite does too. It includes a standard block for Markdown, so you can switch modes seamlessly.
Rich content support: Tables, images, table of contents, and all sorts of lists are all supported.
Extensibility: Extend Podlite with your own custom blocks and inline codes to fit your needs

Podlite doesn't adhere to any specific programming language. This allows it to be embedded in any programming language that supports block-level comments, or multi-line comments.

For example, in JavaScript:

/*
=head1 Documentation

=begin Mermaid
graph LR
        A-->B
        B-->C
        C-->A
        D-->C
=end Mermaid
=begin markdown

# header

 * text
 * text

=end markdown
*/

open this sample at pod6.in

Blocks can be represented in three equivalent forms: delimited style, paragraph style, and abbreviated style.

=begin table :caption<Summary>
  Constants           1
  Variables           10
=end table

=for table :caption<Summary>
  Constants           1
  Variables           10

=table
  Constants           1
  Variables           10

open this sample at pod6.in

Podlite is perfect for creating documentation, blogs, educational materials, and much more.

Current status of Podlite:

currently in beta, with ongoing work for the next version.
there's a reference implementation driving web publishing package and a web editor .
and yes, there's an editor/viewer for desktop too: https://github.com/podlite/podlite-desktop.

This is an early announcement to gauge interest in this markup language.

Find out more:

Specification : https://github.com/podlite/podlite-specs, [in html format]
github: https://github.com/podlite ⭐️
website: https://podlite.org
web playground: https://pod6.in

The Podlite specification is published under the Artistic license 2.0.

I'd be incredibly grateful for any feedback and ideas.

Thank you so much for your time!

Best regards, Alex

Podlite: Modernizing and Extending abandoned Raku Pod (ака pod6)

Alexandr Zahatski — Wed, 18 Oct 2023 13:16:49 +0000

Podlite was born as a lightweight implementation of Raku Pod (also known as pod6), and over time, it has evolved into one of the most comprehensive implementations. It encompasses:

Libraries for TypeScript
A web editor - pod6.in
A free desktop editor - Podlite-desktop
A package for creating modern web applications: Podlite for Web

What's more, Podlite also supports Diagrams, auto-generated Table of Contents, and has built-in Markdown support.

I've been keeping daily journals in Raku Pod format for years and using Podlite Desktop to write blog articles.

At this point, I've accumulated a bunch of ideas that go beyond the standard Raku Pod (aka pod6) specification, along with some ideas I've been wanting to implement for a while. I've brought them all together, and I'd like to share the key ones in detail.

Selectors

Podlite selectors are, in essence, quite similar to CSS selectors. They help identify and filter specific blocks within documents. Each selector pattern can contain optional block sources and block names.

The general syntax is as follows:

<EXTERNAL_SOURCE>
or
[ EXTERNAL_SOURCE | ] <BLOCKS_SELECTOR>

For example:

head1, head2

This selector defines all level 1 and level 2 header blocks.

para,code

This selector defines all paragraph and code example blocks.

Selectors can be used not only to describe blocks within the current document but also in external documents:

file:article.rakudoc

This selector points to all blocks in the article.rakudoc file.

file:article.rdoc | head1, head2

All head1 and head2 blocks from the article.rdoc file.

Here are a few more examples:

Selector	Description
head1, head2, item1	All head1, head2 and item1 blocks from document
file:article.rakudoc \| head1, head2	All head1 and head2 blocks from arricle.rakudoc file
file:./includes/*.pod6 \| head1, head2	All head1 and head2 blocks from pod6 files placed in includes directory
doc:Data::Dumper \| code	All code blocks from a module documentation
file:/docs/*/.md \| head1	Search for first-level headers in all ".md" files within the "docs" directory and its subdirectories.

Selectors are an essential part that will be used in other sections.

=toc - Automatic table of contents

 =toc <SELECTOR>

The =toc block is used to create an autogenerated table of contents (TOC) in a document. The TOC serves as an index of section titles within the document, and its structure is determined by the organization of the document.

For example:

 =toc head1, head2, head3, item1, item2, table

In this block, a selector is used to describe the blocks used to build the TOC.

You can create lists of tables or even images:

=for toc :title('List of tables')
table

=for toc :title('List of media')
Image, Diagram

=include - Include block

    =include <SELECTOR>

The =include block is a powerful tool for reusing specific parts of documents within project sources. This is particularly handy when dealing with complex documents that require to include certain sections from different files while keeping the overall context and structure intact.

This block is perfect for creating books. Combined with Selectors, it allows you to include arbitrary blocks from other documents and files.

=picture, P< > - Inserting pictures

To insert pictures, you can use the =picture block:

=picture site-menu.png
This is the menu rendered by the React component

It may be rendered as follows:

and inline usage:

 =para In the vast expanse of the cosmos, an intrepid P<astronaut|astronaut.png>
 floats weightlessly above the Earth.

E<:hugging face:> - emoji 🤗

To include emoji codes, you can use the E<> code along with the colon-prefixed and postfix emoji shortname:

    Podlite uses emoji codes to express emotions and actions,
    such as E<:thumbsup:> for approval and E<:smile:> for happiness.

it renders as:

=formula, F< > - mathematical formulas

To include mathematical formulas, use a =formula block with an inline version represented as F<>.

To insert mathematical expressions, use LaTeX-style syntax, which is a commonly used format for writing mathematical equations.

For example:

  =formula
  x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

  In a right triangle, the length of the hypotenuse can be calculated 
  using the Pythagorean theorem: F<a^2 + b^2 = c^2>.

  Euler's identity, F<e^{i\pi} + 1 = 0>, is a fundamental equation in
  complex analysis.

may render as:

  =formula  :caption<Quadratic Formula> 
  x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

It may be rendered as:

=item, :checked - Task lists

In addition to the ordered list would be nice to support task lists, which are commonly known as checklists or to-do lists.

To create a task list item just apply a :checked attribute to =item block.

 =for item :checked
 Buy groceries
 =for item :!checked
 Clean the garage

 =item1 [ ] Work
   =item2 [ ] Prepare the presentation
   =item2 [x] Send emails
 =item1 [ ] Home
   =item2 [ ] Vacuum the living room
   =item2 [ ] Water the plants

Which might look something like this:

Contextual backlinks

Yeah, that's one of the ideas I've been thinking about lately.

Contextual backward links W<> (or contextual backlinks), enhance the traditional linking mechanism by allowing to not only reference another location but also provide specific context around that reference. This context can take the form of opinions, additional information, or any relevant commentary that enhances the understanding of the referenced material.

For example:

 This text can reveal the meaning of W<glossoligation|defn:glossoligation>

or:

 We discuss here about W<doc:perldata>.

Contextual backlinks on the destination page can be displayed in various ways. They may appear with surrounding text chunks, providing context within the flow of the content. Alternatively, they can be placed at the end of the text, in the margin of the page, or highlighted in other visually distinctive ways.

=markdown - Integration with Markdown

Since last year, Podlite natively supports Markdown using the =Markdown block. This means that Markdown elements are translated into the Podlite AST, allowing features not available in Markdown, such as auto-generated TOCs.

For instance:

=Toc head1, head2, head3

=head1 This is header1
=head2 Another header

=begin Markdown

# this is markdown header
## and this!

=end Markdown

This document would look like this:

You can play around with an example here.

The synergy between two markup languages is fascinating.

Here's another example that I'd like to make a reality:

=include article.md
=include file:./includes/*.md

I like the idea of further integration.

Conclusion

These are some of the major improvements that Podlite brings. Many of these suggestions have already been implemented in Podlite and have proven their practical usefulness.

I took the current specification for Raku Pod (aka Synopsis 26), updated it, and incorporated all my ideas into it. I presented it as a specification for Rakudoc.

As a result, the Rakudoc proposal:

Is 100% compatible with already written documentation in Raku Pod (aka Pod6), guaranteed by using the current specification as a base (Synopsis 26).
Maintains simplicity and elegance.
Remains extensible.
Empowers users with new blocks and formatting codes.

I'm open to ideas and suggestions. Feel free to send it to zag(at)cpan.org. I'm looking forward to hearing from you!

In the meantime, I'll continue working on Podlite Editor and Podlite itself.

Thank you for your attention!

With best regards, Alex

PS. I recently noticed an intriguing event on the calendar – a POD birthday celebration marked with the comment '1994.10.18'. Although I couldn't find any confirmation of this event, it seemed like a good reason to dive into this topic and write this article. 😄

Reinventing Pod6: Moving Forward

Alexandr Zahatski — Sun, 02 Jul 2023 17:08:19 +0000

Today is a great day because I feel that some interesting changes are happening in an important aspect of my work.

Recently, I've become involved in the process of working on a new specification for the Pod6 markup language. Documentation is a crucial part of any programming language, and despite that, Pod6 has remained unchanged for quite a while. So, the fact that the relevance of Pod is being addressed and taking a step forward is truly commendable. I want to extend my sincere appreciation to you, Richard (@finanalyst), for this.

As I started reviewing early version of Rakudoc, which Richard sent to me, I realized that I have a wealth of ideas and experience with Pod6 that I've been preparing for this moment. They are needs to be organized, put into the text, and shared. It would also be beneficial to review ideas, previous work, revisit all the discussions that have taken place in the Raku/Doc community, which will require some time.

So, I've informed Richard that I'll be preparing my version of specification of the "next Pod".

I estimate that this process will take around 3 weeks. Maybe a little bit less, or more.

I believe that considering multiple viewpoints will be highly beneficial, especially at this early stage.

To keep things focused and avoid any unintended consequences due to my own oversight, I've decided to work on this project in a quiet mode and will share a diary of my progress once the work is completed.

In addition to my work on the new Pod6 specification, I've also decided to take a pause on working on the next release of Podlite editor.

Thank you for your attention!

With best,
Alex

DEV Community: Alexandr Zahatski

Podlite Desktop 0.7.0 — smart lists, code folding

What's new in 0.7.0

One command to add structured markup to your AI agent

The problem I kept running into

What Podlite gives you

How this plays out in practice

Installing podlite-skills

What I actually use it for

The Block Structure of Podlite

Abbreviated blocks (=BLOCK)

Paragraph blocks (=for BLOCK)

Delimited blocks (=begin BLOCK … =end BLOCK)

Links

Podlite Desktop Editor 0.6.1 is out

What's Podlite?

What's new in 0.6.1

Download

📝 Inline text formatting in Podlite editor

✨ Supported Formatting Codes

Web editor with Podlite markup language syntax highlighting is here!

Podlite: Powering Up Knowledge Management

What's New? 🚀

See It in Action 👀

The Raku Knowledge Base v1.0 (Artistic 2.0 License)

Get Involved 🤝

Excited to announce that Podlite's TypeScript implementation now supports formulas! 🧮✨

Podlite v1.0 released: A lightweight block-oriented markup language for organizing knowledge

What is Podlite?

Key Features of Podlite

Podlite v1.0 Release Notes

Customization and Extensibility

Processing and data handling

Content Structuring and Navigation

Document Presentation Enhancements

Deprecated/removed

Summary of Release

Feedback and Contributions

Introducing Podlite, a lightweight block-based markup language

Podlite: Modernizing and Extending abandoned Raku Pod (ака pod6)

Selectors

=toc - Automatic table of contents

=include - Include block

=picture, P< > - Inserting pictures

E<:hugging face:> - emoji 🤗

=formula, F< > - mathematical formulas

=item, :checked - Task lists

Contextual backlinks

=markdown - Integration with Markdown

Conclusion

Reinventing Pod6: Moving Forward

Abbreviated blocks (`=BLOCK`)

Paragraph blocks (`=for BLOCK`)

Delimited blocks (`=begin BLOCK` … `=end BLOCK`)