## -*- coding: utf-8;mode: org; -*- ## This file is best viewed with GNU Emacs Org-mode: http://orgmode.org/
«A designer knows he has achieved perfection not when there is nothing left to add, but when there is nothing left to take away.» (Antoine de Saint-Exupéry)
This is a web log (blog) environment for GNU Emacs with Org-mode which generates static HTML5 web pages. In my opinion, it is much more superior to any other Org-mode-to-blog-solution I have seen so far when it comes to minimal blogging effort and advanced features that support my blogging experience.
<(All?) your Org-mode files> --lazyblorg--> static HTML pages
|
v
optional upload (shell) script
|
v
your web space
There is a list of similar/alternative Org-mode blogging projects whose workflows seem really tedious to me.
See my original post to the Org-mode ML for how this idea of lazyblorg started in 2011.
This awesome piece of software is a sheer beauty with regard to:
- simplicity of creating a new blog entry
- I mean it: there is no step which can be skipped!
- add heading+content anywhere, add ID, tag, invoke lazyblorg
- I mean it: there is no step which can be skipped!
- integration into my personal, published workflows
- here, you have to either adapt my totally awesome workflows or you
have to find alternative ways of doing following things:
- linking/including image files or attachments in general (I use this Memacs module)
- advantage of my method: I simply add an image file by typing
tsfile:2014-03-03-this-is-my-file-name.jpgin double-brackets and I really don’t care in which folder the file is currently located on my system
- advantage of my method: I simply add an image file by typing
- copying resulting HTML files to web-space (I do it using
unison/rsyncSyncthing.net)
- linking/including image files or attachments in general (I use this Memacs module)
- here, you have to either adapt my totally awesome workflows or you
have to find alternative ways of doing following things:
I wrote lazyblorg to get a blogging system that works for me exactly the way I need it. I did not write lazyblorg for the pleasure on the coding process - I just wanted to get the resulting thing working in order to be able to blog the way I want to blog.
Therefore, it’s mostly a works-for-me project. I won’t add anything that I don’t use myself.
For the same reason, I won’t accept pull requests for things like:
- Features I don’t use myself.
- Added complexity I don’t want.
- Features or dependencies I don’t understand completely.
- Stuff that might interfere with the way I’m using lazyblorg.
If you do want to adapt lazyblorg and implement your own features that conflict with the things listed above, I’d like to see you creating a fork of this project. If you drop me a line with a description how your fork differs from the original, I’m glad to add it to this README file.
If you think that your idea might be also a good one for me, you can always hand in a pull request and I’ll have a look if I’m willing to add it. However, don’t be disappointed if I don’t. I want to keep the time spent on lazyblorg at a minimum. My personal priority is visible in the lazyblorg issues where I introduced tags for high and low priority things to implement.
Lazy users of Org-mode who want to do blogging very easily and totally cool.
Or simply wannabes. I’m perfectly fine with this as long as they use lazyblorg. ;-)
Pages using lazyblorg are listed on my personal tag page on “lazyblorg”. Please do drop me a line when you want to get your page added to the list.
Quote from Sepp Jansen:
[…]
But when I revisited lazyblorg after studying the other packages, it suddenly seemed like a better solution. After only a short time of reading I figured out the entire templating and post generation system. Although not the most elegant, it is super simple and easy to understand. And those are my most important points.
The developer states that it is easy to configure and start building, and is absolutely right.
In just a few hours I went from installing dependencies to having a fully working website, including some layout and CSS customization. The included HTML and CSS is easy to modify so I could (lazily) make the site look like I wanted it to without too much digging in many little files. I even managed to make it look a lot like my old site without too much effort! Lazyblorg really lives up to its name!
[…]
I really like lazyblorg, and I’ll happily manage this website with it for as long as possible.
Well, as of 2026-03, his website is not available any more. You can see some older snapshots via WaybackMachine though.
- modifying configuration settings, e.g., in script files
- optional: creating scheduled tasks (cronjob, …) if you are a really lazy one (and if you trust lazyblorg to do its job in the background)
lazyblorg is written in Python 3.
Development platform is Debian GNU/Linux. So with any decent GNU/Linux you should be fine.
It might work on macOS but I never tried it so far and I probably never will. Reach out to me if you’ve tried.
I definitely does not work with native Microsoft Windows.
Although a programmer can add a couple of os.path.thisorthat() here and there
and it should be good to go.
Please consider sending a pull-request if you are fixing this issue.
Thanks!
Windows including the Windows Subsystem for Linux looks promising. It might as well work as with any full-blown Linux system.
Currently (2026-03-21), I consider lazyblorg in productive status. It just works for me very well.
I don’t maintain a specific changelog. However, when there are substantial changes to lazyblorg, you maybe will find a blog article tagged with “lazyblorg”. Use an RSS/Atom aggregator to follow the blog.
All updates and new features are visible in the repository history. That’s the most important source for updates.
As of 2025-12-13, I migrated this project to uv which resulted in
manifold changes related to the wrapper shell scripts, environment
variables used for the shell scripts and pytest invocation. This has
simplified stuff.
Minimum effort for blogging.
And: your blog entries can be written anywhere in your Org-mode files. They will be found by lazyblorg. :-)
Further advantages are listed below.
- write a blog entry anywhere in your Org-mode files
- With lazyblorg, you can, e.g., write a blog article about an event as a sub-heading of the event itself!
- tag your entry with
:blog:(or whatever tag you’ve defined withinTAG_FOR_BLOG_ENTRYin theconfig.py) - add an unique ID in the PROPERTIES drawer
- set the state of your entry to
DONE- make sure that a
:LOGBOOK:drawer entry will be created that contains the time-stamp
- make sure that a
An example blog entry looks like this:
** DONE An Example Blog Post :blog:lazyblorg:software:
CLOSED: [2017-06-18 Sun 00:16]
:PROPERTIES:
:ID: 2017-07-17-example-posting
:CREATED: [2017-06-17 Sat 23:45]
:END:
:LOGBOOK:
- State "DONE" from "NEXT" [2017-06-18 Sun 00:16]
:END:
[…]
Today, I found out that…
Note that the tags “lazyblorg” as well as “software” aren’t required for a minimal blog article.
That’s it. lazyblorg does the rest. It feels like magic, doesn’t it? :-)
These things make a blogger a happy one:
No other Org-mode blogging system I know of is able to process blog entries which are scattered across all your Org-mode documents except the usual org-export-based approaches.
No other Org-mode blogging system I know of is able to generate a blog entry with that minimum effort to the author.
You do not need to maintain a specific Org-mode file that contains you blog posts only. Create blog posts anywhere in between your notes, todos, contacts, …
And there are some technological advantages you might consider as well:
- You don’t need to write or correct HTML code by yourself.
- produces static, state-of-the-art HTML5
- it’s super-fast on delivery to browsers
- very low computing requirements on your web server: minimum of server load
- No in-between format or tool.
- Direct conversion from Org-mode to HTML/CSS.
- dependencies have the tendency to cause problems when the dependent tools change over time
- lazyblorg should be running fine for a long time after it is set up properly
- Decide by yourself how and where you are hosting your blog files and log files.
- you will find more advantages when running and using lazyblorg - I am very confident about that ;-)
- lazyblorg offers so many cool little features as you can read in the “Features” section.
Yes, there are some disadvantages. I am totally honest with you since we are becoming close friends right now:
- lazyblorg re-generates the complete set of output pages on every run
- this will probably changed in a future release (to me: no high priority)
- most of the time this is not an issue at all
- if pages are generated on a different system as the web server runs on, performance is a minor issue
- if you don’t have thousands of pages, this will not take long
- lazyblorg is implemented in Python:
- Its Org-mode parser supports only a (large) sub-set of Org-mode syntax
and features.
- Basic rule: use an empty line between two different syntax elements such as paragraphs, lists, tables, and so on.
- Whenever I think that an additional Org-mode syntax element is needed for my blog, I start thinking of implementing it
- I am using Pandoc as a fall-back for all other Org-mode syntax elements which works pretty fine
- For a list of general Org-mode parsers please read this page
- Its Org-mode parser supports only a (large) sub-set of Org-mode syntax
and features.
- lazyblorg is using state-of-the art HTML5 and CSS3
- No old HTML4.01 transitional stuff or similar
- Results might not be compatible with very old browsers such as Internet Explorer or some mobile devices.
- You have to accept the one-time setup effort which requires
knowledge of:
- using command-line tools
- modifying configuration files
- summary: getting this beautiful thing to work in your environment
- Updating your lazyblorg setup after you’ve customized it requires manual steps so that you re-apply your customizations. See chapter “How to Upgrade lazyblorg to a Newer Version” below for the workflow.
- As lazyblorg is a works-for-me project: see chapter “DISCLAIMER: This is a personal project”
«Technology develops from the primitive via the complex to the simple.»
(Antoine de Saint-Exupéry; note: lazyblorg is currently “primitive” but with a great outlook up to the status of being simple)
Here is a selection of features of lazyblorg which helps you to blog efficiently:
- Converts Org-mode To HTML5: lazyblorg supports a (large sub-)set of
syntax elements of Org-mode
- also see FAQs for “What Org-mode elements are supported by lazyblorg?”
- Different page types allow you to create:
- articles related to a specific date (temporal pages)
- Those articles are published and hardly updated.
- articles not related to a specific date (persistent pages)
- Frequent updates or the absence of any day-relation makes this page type very sexy to use.
- articles describing a tag you are using (tag pages)
- Yes, with lazyblorg, you are (optionally) able to explain how you are using a certain tag. You can link your most important tag-related articles and so forth. Most systems don’t offer any possibility to communicate the meaning of the tags used.
- the entry page of your blog
- You gotta give them a starting page ;-)
- the templates which are used to generate your blog pages
- Hooray, you are able to define all templates of your blog within Org-mode as well. No need to edit source code here. Isn’t this great?
- articles related to a specific date (temporal pages)
- Adding language tags via auto-tags feature.
- Reading time estimations (multi-language).
- There is a search feature which brings you to the content by searching for keywords or phrases.
- Multiple ways of adding comments: via good old email, Disqus and most important: Mastodon. (See this German article for details on how I think that Fediverse hashtags are a valid aproach to blog comments.)
- To efficiently notify users of new articles or changes to existing
articles, lazyblorg generates RSS/ATOM feeds.
- See the tag pages and their TagTree drilldown for feeds on single tags or even combinations of tags!
- Really easy to use linking to other blog articles using their ID property.
- You can exclude content from being published with various features:
- Comment lines
- Mark an article/heading as hidden using the tag NOEXPORT
- The hidden tag does publish an article but hides it from the entry page, navigational pages, and the feeds. This way, you can publish pages who can only be access by people knowing its URL.
- Snippets: Define reusable content fragments (small or very large) as
Org-mode entries and reference them from any blog article using
their ID property
id:snippet-idas reference. Supports inline and block replacement, heading level adaptation, and nesting. - At the bottom of each article, there is a list of related articles that back-link to here.
- You can very easily embed image files with automatically scaling to
their desired width
- This feature is hardened against moving image files to different folders!
- Users of Memacs do have advanced possibilities here as well.
- An optional image cache directory holds previously resized image file and therefore prevents resizing effort for each run.
- For navigating through the blog articles I do recommend using the
tags. Articles related to one topic share common tags whereas a
date-oriented archive has only very limited use. The tag cloud which
is on the tag overview page offers a quick overview of your most used
tags.
- TagTrees offer an advanced way of navigating through articles by combining multiple tags. Starting from any tag page, readers can drill down by selecting additional tags to narrow down the list of matching articles. This is ultra-cool if you grasp its power. For example, this page holds all articles tagged with “emacs” as well as “education”. And you get an Atom feeds for that combination of tags as well.
- Easy embedding of external content such as Tweets or YouTube videos.
- With the command line parameter
--external-url-fileyou can generate a TSV file listing all external URLs found across your blog articles. This is useful as input for external URL checker tools to detect broken links. The file includes the URL, the number of articles referencing it, the article IDs, and link descriptions. - You can see the article Orgdown source via the π-symbol in the upper right corner.
There are five different types of pages in lazyblorg. Most of the time, you are going to produce temporal pages. However, it is important to understand the other ones as well.
In order to process a blog-heading to its HTML5 representation, its
Org-mode file has to be included in the --orgfiles command line
argument of lazyblorg.py. Do not forget to include the archive files
as well.
- temporal
- persistent
- tags
- entry page
- templates
Please do read https://github.com/novoid/lazyblorg/wiki/Page-Types for important details.
I am using lazyblog for my own blog “publicvoit” and therefore it gets more and more ready to use as I add new features for myself.
The number of external dependencies is kept at a minimum.
This is a list of the most important dependencies:
- Python uv for dependency management and running all the important parts of lazyblorg: tests, blog generation process, …
- Werkzeug
- for sanitizing path components
- I installed it on Debian GNU/Linux with
sudo apt-get install python3-werkzeug
- pickle
- object serialization
- most likely: should be part of your Python distribution
- pypandoc
- some Org-mode syntax elements are being converted using Pandoc and its Python binding pypandoc
- you can get it via
sudo apt-get install pandocandsudo pip install python3-pypandoc - Note: Debian GNU/Linux 8 (Jessie) comes with a Pandoc version
which is has bugs. Please install a more recent version. I
upgraded to
pandoc-1.15.1-1-amd64.debfrom: http://pandoc.org/installing.html
- opencv-python
- lazyblorg scales embedded images according to the HTML export attributes
- Install using
sudo apt-get install python3-opencv
- Sass (optional) if you want to generate your CSS from the scss-file
- orgformat
- This is my library that provides basic utility functions when working with Org mode strings
All other libraries should be part of a standard Python distribution.
Running tests also requires `pytest`.
You can get all the dependencies via uv using:
change to your local lazyblorg directory that contains the lazyblorg version of "pyproject.toml": uv --project . run ./lazyblorg.py --help
That should resolve all dependencies and show you the help information.
- Get the source
git clone https://github.com/novoid/lazyblorg.gitor download current version as ZIP file
- Adapt
config.pyto meet your settings. - Do a technological test-drive
- start:
lazyblorg/example_invocation.sh - this should work with GNU/Linux (and most probably OS X)
- if not, there is something wrong with the set-up; maybe missing external libraries, wrong paths, …
- start:
- Study, understand, and adopt the content of example_invocation.sh
- with this, you are able to modify command line parameters to meet your requirements
- if unsure, ask for help using
uv --project . run lazyblorg.py --help
- Get yourself an overview on what defines a lazyblorg blog post and
write your own blog posts. A (normal temporal) blog article consists of:
- A (direct) tag has to be
blog- Sorry, no tag inheritance. Every blog entry has to be explicitly tagged.
- You have to add an unique
:ID:property - The entry has to be marked with
DONE - A
:LOGBOOK:entry has to be found with the time-stamp of setting the entry toDONE- in my set-up, this is created automatically
- Note that you don’t need to take care of the
:CREATED:property as well as the:LOGBOOK:drawer as long as you’re using following settings:(setq org-log-into-drawer t) ;; Write state changes into a =:LOGBOOK:= drawer (setq org-log-done 'time) ;; Record a timestamp when switching to =DONE= (org-expiry-insinuate) ;; Automatically write =CREATED= properties in the =PROPERTIES= drawer (setq org-expiry-inactive-timestamps t) ;; Set the timestamps of =expiry.el= to inactive ones
- Get yourself familiar on the sub-set of Org-mode syntax you can use with lazyblorg
- Always put an empty line between different syntax elements such as a heading and the next paragraph, normal text and a list or a table, and so forth.
- You should not get a disaster if you are using elements lazyblorg is not optimized for. The result just look different than expected.
- However, “unknown” Org-mode elements are automatically converted through pandoc as a fall-back. So those cases should be extremely rare.
- A (direct) tag has to be
- OPTIONAL: Write your own CSS file
- you can take a look on mine if you do not care that I am not really into Web design :-)
- please replace hard-coded URL to CSS file in lazyblorg/templates/blog-format.org and link it to your CSS file
- OPTIONAL: Adopt the blog template
- default template is defined in lazyblorg/templates/blog-format.org
- OPTIONAL: Create tag pages for your most important tags where you describe how you are using this tag, what are the most important blog entries related to the tag and so forth.
- Publish your pages on a web space of your choice
- publishing can be done in various ways. This is how I do it using
lazyblorg/regenerate_public_voit.shwhich is an adopted version oflazyblorg/example_invocation.sh:- invoking
start_all_tests.sh- this is for checking whether or not recent code changes did something harmful to my (unfortunately very limited) set of unit tests
- invoking
lazyblorgwith my more or less fixed set of command line parameters - invoking
rsync -av testdata/2del/blog/* $HOME/public_html/- it synchronizes the newly generated blog data to the local copy of my web space data
- this separation makes sense to me because with this, I am able to do test drives without overwriting my (local copy of my) blog
- (wait for Syncthing to do its job in the background)
- in order to transfer my local copy of my web space data to my public web space
- invoking
- This method has the advantage that generating (invoking
lazyblorg) and publishing are separate steps. This way, I can locally re-generate the blog (for testing purposes) as often I want to. However, as long as I do not sync it to my web space, I keep the meta-data (which is in the local web space copy) of the published version (and not the meta-data of the previous test-run).
- publishing can be done in various ways. This is how I do it using
- Have fun with a pretty neat method to generate your blog pages
Because we are already close friends now, I tell you a hidden feature of lazyblorg nobody knows yet: whenever you see a π-symbol in the upper right corner of a blog entry on my blog: this is a link to the original Org-mode source of that page. This way, you can compare Org-mode-source and HTML-result right away. Isn’t that cool? :-)
Since lazyblorg is a works-for-me project, there is no automated
upgrade mechanism. Upgrading requires a few manual steps, especially
if you have customized config.py or the templates.
Before pulling any updates, make copies of the files you have modified:
cp config.py config.py.MY_BACKUP cp templates/blog-format.org templates/blog-format.org.MY_BACKUP
If you have a custom CSS or SCSS file derived from the included one, back that up as well:
cp templates/public_voit.scss templates/public_voit.scss.MY_BACKUP
Also back up your invocation shell script if you based it on
example_invocation.sh:
cp my_invocation.sh my_invocation.sh.MY_BACKUP
cd /path/to/lazyblorg git pull
If you get merge conflicts (because you edited tracked files like
config.py directly), git will tell you. In that case, resolve the
conflicts manually or use git stash before pulling and git stash
pop afterwards.
This is the most important step. New versions of lazyblorg may
introduce new configuration variables in config.py that your old
copy does not have.
Compare the upstream config.py with your backup:
diff config.py.MY_BACKUP config.py
Look for:
- New variables that were added (you need to add them to your config with values matching your setup)
- Changed default values that might affect your blog
- Removed or renamed variables (rare, but possible)
Transfer your personal values (author name, domain, URLs, paths, …)
from your backup into the new config.py. Do not simply overwrite
the new config.py with your old backup – you would lose any newly
introduced settings.
If I do need to merge/adapt very similar files, I prefer to use Meld
for it. meld file1 file2 opens up a GUI window where you see their
differences. Either via keyboard shortcuts or via mouse you’re able to
move content from left to right or vice versa. Furthermore, you can
edit both files manually. Therefore, it gives you maximum flexibility
here.
Similarly, compare the template file:
diff templates/blog-format.org.MY_BACKUP templates/blog-format.org
New template elements or placeholder variables may have been added.
If you have customized the templates, merge the upstream changes into
your version carefully. Pay attention to new #PLACEHOLDER# variables
that the new code might expect.
After pulling, make sure all Python dependencies are up to date:
uv --project . run ./lazyblorg.py --help
This resolves any new or updated dependencies via uv and verifies
that lazyblorg starts without errors.
uv --project . run pytest
If all tests pass, your setup is consistent with the new version.
Generate your blog into a temporary directory to verify everything looks correct before publishing:
uv --project . run ./lazyblorg.py \ --targetdir "/tmp/lazyblorg-upgrade-test" \ --previous-metadata "/tmp/lazyblorg-upgrade-test/metadata.pk" \ --new-metadata "/tmp/lazyblorg-upgrade-test/metadata.pk" \ --logfile "/tmp/lazyblorg-upgrade-test/logfile.org" \ --orgfiles your-org-files.org templates/blog-format.org
Open a few generated pages in your browser and check that they look as expected.
Once you are satisfied that everything works, you can remove the backup files:
rm config.py.MY_BACKUP rm templates/blog-format.org.MY_BACKUP
- Keep your customizations minimal. The less you change in
config.pyand the templates, the easier upgrades will be. - Consider subscribing to the lazyblorg blog tag via RSS/Atom to stay informed about important changes.
- If you track your lazyblorg setup in your own git repository, you
can use
git diffbetween versions to see exactly what changed upstream.
It is tedious to re-generate the whole blog and even upload it to your web-space just to check the HTML version of the article you are currently writing.
Yeah, this also sucks at my side.
Good news everybody: There is a simple method to preview the article
under the cursor. The script preview_blogentry.sh contains an ELISP
function that extracts the current blog article (all lazyblorg criteria
has to be fulfilled: ID, blog tag, status DONE), stores it into a
temporary file, and invokes lazyblorg via preview_blogentry.sh with
this temporary file and the Org-mode file containing the format
definitions.
If this worked out, your browser shows you all generated blog articles.
Please do adopt the mentioned scripts to you specific requirements - the ones from the repository are for my personal set-up which is unlikely to fit yours (directory paths mostly).
Bang! Another damn cool feature of lazyblorg. This is going better and better. :-)
Imagine, you’re looking at a blog article of your nice lazyblorg-generated blog. Now you want to go to the corresponding Org-mode source to fix a typo.
The issue here is, that you have to either know, where your heading is located or you have to go to the HTML page source, extract the ID, and jump to this ID.
I’ve got a better method: put the URL of your blog article into your
clipboard (via C-l C-c), press a magic shortcut in Emacs, and BAAAM!
you’re right on spot.
How’s that magic happening?
Just use the following Emacs lisp code snippet, adapt the domain
string, and assign a keyboard shortcut:
(defun my-jump-to-lazyblorg-heading-according-to-URL-in-clipboard ()
"Retrieves an URL from the clipboard, gets its Org-mode source,
extracts the ID of the article and jumps to its Org-mode heading"
(interactive)
(let (
;; Getting URL from the clipboard. Since it may contain
;; some text properties we are using substring-no-properties
;; function
(url (substring-no-properties (current-kill 0)))
;; This is a check string: if the URL in the clipboard
;; doesn't start with this, an error message is shown
(domain "http://karl-voit.at")
)
;; Check if URL string is from my domain (all other strings do
;; not make any sense here)
(if (string-prefix-p (upcase domain) (upcase url))
;; Retrieving content by URL into new buffer asynchronously
(url-retrieve url
;; call this lambda function when URL content is retrieved
(lambda (status)
;; Extrating and preparing the ID
(let* (
;; Limit the ID search to the top 1000 characters of the buffer
(pageheader (buffer-substring 1 1000))
;; Start index of the id
(start (string-match "<meta name=\"orgmode-id\" content=\"" pageheader))
;; End index of the id
(end (string-match "\" />" pageheader start))
;; Amount of characters to skip for the openning tag
(chars-to-skip (length "<meta name=\"orgmode-id\" content=\""))
;; Extract ID
(lazyblorg-id (if (and start end (< start end))
;; ... extract it and return.
(substring pageheader (+ start chars-to-skip) end)
nil))
)
(message (concat "Looking for id:" lazyblorg-id " ..."))
(org-open-link-from-string (concat "id:" lazyblorg-id))
)
)
)
(message (concat "Sorry: the URL \"" (substring url 0 (length domain)) "...\" doesn't start with \"" domain "\". Aborting."))
)
)
)- Do read the Wiki for embedding external stuff like Tweets or YouTube videos.
You can start the unit tests via:
uv --project . run pytest
… which is also part of the wrapper script start_unit_tests.sh
You can start the end to end tests which generates an example blog content via the script file start_end-to-end-test.sh
The links to the CSS & co, even on the homepage, start with a slash which means you can’t easily have a look at the HTML locally by opening the files, you need to spin up a webserver.
If you want to learn how to move to a more flexible setup, read this comment and follow its instructions.
I’m glad if you like my tool. I’ve got way more projects on:
- GitHub (oldest projects),
- GitLab.com (older projects), and
- Codeberg (newest projects).
If you want to support me:
- Send old-fashioned postcard per snailmail - I love personal feedback!
- see my address
- Send feature wishes or improvements as an issue
- Create issues for bugs
- Contribute merge requests for bug fixes
- Check out my other cool projects on the platforms above
If you want to contribute to this cool project, please fork and contribute!
I am using Python PEP8 and occasionally some ideas from Test Driven Development (TDD). I fancy Python3 with type annotations, although I’m not using them everywhere at the moment. Starting with 2025, I began to use help from Claude.ai which is a huge improvement, given my lack of programming practice and knowledge.
After all, each of my tools was developed because I needed its functionality and could not get it elsewhere - at least to my knowledge or taste.
