openjournal - User contributions [en]

MediaWiki:Common.js

2026-09-10T19:58:31Z

OpenJournalAdmin: openjournal markdown shortcuts

/*!
* openjournal -- Markdown shortcuts for the visual editor.
*
* Loaded into MediaWiki:Common.js by the seed step. Edit it on-wiki at
* /wiki/MediaWiki:Common.js, or here and re-seed.
*
* MediaWiki stores wikitext, not Markdown, and that does not change here.
* What changes is what happens as you type: the visual editor already turns
* "* " into a bullet and "1. " into a numbered list, so the rest of a writer's
* Markdown muscle memory is registered the same way. You type Markdown, the
* editor formats it immediately, and the page is still wikitext underneath --
* which keeps diffs, templates and the API working exactly as before.
*
* These use ve.ui.sequenceRegistry, VisualEditor's own public mechanism for
* this, and follow the same pattern as its built-in registrations.
*/
( function () {
'use strict';

// Names of the commands the inline shortcuts run, and whether registration
// has already happened. Both hooks below are safe to run more than once.
var inlineCommandNames = [],
registered = false;

/**
* A sequence that fires at the start of a paragraph, e.g. "## " or "> ".
*
* @param {string} name Registry name; reusing an existing name replaces it
* @param {string} command VisualEditor command to run
* @param {string} prefix Characters typed before the space
* @param {boolean} space Whether a trailing space is part of the trigger
* @return {ve.ui.Sequence}
*/
function paragraphPrefix( name, command, prefix, space ) {
var data = [ { type: 'paragraph' } ].concat( prefix.split( '' ) );
if ( space ) {
data.push( ' ' );
}
// Strip everything the user typed; the paragraph element is not typed.
return new ve.ui.Sequence( name, command, data, data.length - 1 );
}

function registerMarkdownSequences() {
var registry = ve.ui.sequenceRegistry,
level;

for ( level = 1; level <= 6; level++ ) {
registry.register( paragraphPrefix(
// MediaWiki registers "# " as a wikitext numbered list under the
// name "numberHash". Reusing that name replaces it, so a lone
// "# " means a heading here, as a Markdown writer expects.
// "1. " still makes a numbered list, which is the Markdown way.
level === 1 ? 'numberHash' : 'openjournalHeading' + level,
'heading' + level,
new Array( level + 1 ).join( '#' ),
true
) );
}

// "- " for bullets. VisualEditor ships "* " already; Markdown uses both.
registry.register(
paragraphPrefix( 'openjournalBulletDash', 'bulletWrapOnce', '-', true )
);

// "> " for a blockquote. MediaWiki maps ": " to this; Markdown uses ">".
registry.register(
paragraphPrefix( 'openjournalBlockquote', 'blockquoteWrap', '>', true )
);

// "```" opens a code block.
registry.register(
paragraphPrefix( 'openjournalCodeBlock', 'preformatted', '```', false )
);

// "---" is a horizontal rule. VisualEditor wants four dashes; Markdown
// takes three, and three fires first, so this supersedes it.
registry.register(
paragraphPrefix( 'openjournalHorizontalRule', 'insertHorizontalRule', '---', false )
);
}

/**
* Inline Markdown: **bold**, *italic*, `code`.
*
* Block shortcuts above are plain sequences, because the characters that
* trigger them sit at the start of a paragraph and VisualEditor's `strip`
* removes them. Inline Markdown wraps text instead, and `strip` only takes
* characters off the right-hand end -- so the opening delimiter would be
* left behind. These use a regular expression to match the whole
* "**text**", select it, and hand it to the action below, which swaps in
* the text without its delimiters and styles it.
*/
function registerInlineAction() {
ve.ui.OpenJournalMarkdownAction = function VeUiOpenJournalMarkdownAction() {
ve.ui.OpenJournalMarkdownAction.super.apply( this, arguments );
};
OO.inheritClass( ve.ui.OpenJournalMarkdownAction, ve.ui.Action );

ve.ui.OpenJournalMarkdownAction.static.name = 'openjournalMarkdown';
ve.ui.OpenJournalMarkdownAction.static.methods = [ 'wrap' ];

/**
* @param {string} delimiter The Markdown characters, e.g. "**"
* @param {string} annotation VisualEditor annotation, e.g. "textStyle/bold"
* @return {boolean} Whether the text was styled
*/
ve.ui.OpenJournalMarkdownAction.prototype.wrap = function ( delimiter, annotation ) {
var surfaceModel = this.surface.getModel(),
fragment = surfaceModel.getFragment(),
text = fragment.getText(),
width = delimiter.length;

// Returning false makes VisualEditor undo the selection change, so
// anything that does not really look like "**text**" is left alone.
if (
text.length <= width * 2 ||
text.slice( 0, width ) !== delimiter ||
text.slice( text.length - width ) !== delimiter
) {
return false;
}

fragment
.insertContent( text.slice( width, text.length - width ), false )
.annotateContent( 'set', annotation )
.collapseToEnd()
.select();

// Without this the annotation stays armed and the next word typed
// comes out bold too.
surfaceModel.setInsertionAnnotations( null );

return true;
};

ve.ui.actionFactory.register( ve.ui.OpenJournalMarkdownAction );
}

function registerInlineSequences() {
[
// label, delimiter, annotation, pattern
[ 'Bold', '**', 'textStyle/bold', '\\*\\*[^*]+\\*\\*$' ],
// "*text*" must not fire midway through typing "**text**", so the
// opening star may not itself be preceded by one. Lookbehind is
// unsupported on some older browsers, hence the per-pattern guard.
[ 'Italic', '*', 'textStyle/italic', '(?<!\\*)\\*[^*]+\\*$' ],
[ 'Code', '`', 'textStyle/code', '`[^`]+`$' ],
// Markdown's other pair of emphasis characters. These refuse an
// opening underscore that follows a word character, which is what
// stops snake_case_names turning italic halfway through -- the
// same rule CommonMark applies, and the reason "_" needs a guard
// that "*" does not. \w covers "_" itself, so it doubles as the
// "not midway through __bold__" check.
[ 'BoldUnderscore', '__', 'textStyle/bold', '(?<!\\w)__[^_]+__$' ],
[ 'ItalicUnderscore', '_', 'textStyle/italic', '(?<!\\w)_[^_]+_$' ],
[ 'Strikethrough', '~~', 'textStyle/strikethrough', '~~[^~]+~~$' ]
].forEach( function ( spec ) {
var name = 'openjournalMarkdown' + spec[ 0 ],
pattern;

inlineCommandNames.push( name );

try {
pattern = new RegExp( spec[ 3 ] );
} catch ( e ) {
mw.log.warn( 'openjournal: skipping ' + name + ' shortcut', e );
return;
}

ve.ui.commandRegistry.register( new ve.ui.Command(
name, 'openjournalMarkdown', 'wrap',
{ args: [ spec[ 1 ], spec[ 2 ] ], supportedSelections: [ 'linear' ] }
) );
ve.ui.sequenceRegistry.register( new ve.ui.Sequence(
name, name, pattern, 0, { setSelection: true }
) );
} );
}

// Register through VisualEditor's plugin hook, which runs after its modules
// load but before the editing surface is built. That timing matters: a
// surface copies the command registry once, at construction, and
// ve.ui.Sequence refuses to run a command the surface does not list. A
// custom command registered any later is silently ignored -- the sequence
// matches, nothing happens. Sequences themselves are read live on every
// keystroke, which is why the block shortcuts survived being registered
// late and the inline ones did not.
function registerEverything() {
if ( registered ) {
return;
}
registered = true;
registerInlineAction();
registerInlineSequences();
registerMarkdownSequences();
}

/**
* Top up the live surface's command list.
*
* The plugin hook below runs early enough that this should be redundant.
* It is here because the failure it guards against is silent: if anything
* builds a surface without the plugin hook having run, every inline
* shortcut matches and then quietly does nothing, which is a miserable
* thing to debug from the outside.
*/
function backfillSurfaceCommands() {
var surface = ve.init && ve.init.target &&
ve.init.target.getSurface && ve.init.target.getSurface();

if ( !surface ) {
return;
}

var commands = surface.getCommands();
inlineCommandNames.forEach( function ( name ) {
if ( commands.indexOf( name ) === -1 ) {
commands.push( name );
}
} );
}

function guard( fn ) {
return function () {
try {
fn.apply( null, arguments );
} catch ( e ) {
// A broken shortcut must never take the editor down with it.
mw.log.error( 'openjournal: Markdown shortcuts failed', e );
}
};
}

mw.hook( 've.loadModules' ).add( guard( function ( addPlugin ) {
addPlugin( guard( registerEverything ) );
} ) );

// Belt and braces, once the editor is actually up.
mw.hook( 've.activationComplete' ).add( guard( function () {
registerEverything();
backfillSurfaceCommands();
} ) );
}() );

MediaWiki:Common.css

2026-09-10T19:58:30Z

OpenJournalAdmin: openjournal styles

/* openjournal -- loaded into MediaWiki:Common.css by the seed step.
Edit it on-wiki at /wiki/MediaWiki:Common.css, or here and re-seed.

Colours are MediaWiki's Codex design tokens rather than literals, so this
file follows the reader's Light/Dark/Automatic choice without needing a
second set of rules. The hex values after each token are the light-mode
fallback, used only if a skin does not define the token. */

.oj-hero {
margin: 0 0 1.5em;
padding: 2em 0 1.6em;
border-bottom: 1px solid var( --border-color-subtle, #c8ccd1 );
}

.oj-hero-title {
font-size: 2.6em;
line-height: 1.1;
font-weight: 700;
letter-spacing: -0.02em;
color: var( --color-emphasized, #101418 );
}

.oj-hero-sub {
margin-top: 0.4em;
font-size: 1.05em;
color: var( --color-subtle, #54595d );
max-width: 34em;
}

/* One article in a feed. */
.oj-entry {
padding: 0.7em 0;
border-bottom: 1px solid var( --border-color-muted, #eaecf0 );
}

.oj-entry a {
font-size: 1.12em;
}

.oj-byline {
color: var( --color-subtle, #54595d );
font-size: 0.88em;
}

.oj-journal .oj-feed {
margin-top: 1.2em;
}

.oj-footnote {
color: var( --color-subtle, #54595d );
font-size: 0.92em;
}

/* The author list is a run of spans; CSS supplies the separators so there is
never a trailing one. */
.oj-authors span + span::before {
content: " \00b7 ";
color: var( --color-subtle, #54595d );
}

/* The "start a new article" box reads as a call to action, not a search field. */
.oj-journal .inputbox-element {
max-width: 26em;
}

/* ---------------------------------------------------------------- Dark mode

Codex's dark palette puts body text at #eaecf0 and headings at #f8f9fa on a
#101418 page: contrast ratios of 15.6:1 and 17.6:1. WCAG AAA asks for 7:1,
so that is roughly twice the contrast anyone needs, and on a near-black
ground it is where text starts to glow and smear (halation).

Soften the text and lift the page a little off black. The ratios below stay
above AAA, so nothing becomes harder to read:

headings #f8f9fa 17.6:1 -> #dfe3e7 13.7:1
body text #eaecf0 15.6:1 -> #ccd1d6 11.5:1
bylines #a2a9b1 7.8:1 -> #9fa6ae 7.2:1

These override Codex tokens, so everything on the page follows -- article
text, the skin's own chrome and the styles above alike. */

.oj-dark-palette,
html.skin-theme-clientpref-night {
--color-base: #ccd1d6;
--color-emphasized: #dfe3e7;
--color-subtle: #9fa6ae;
--background-color-base: #17191c;
}

/* The same, for readers on Automatic whose system is set to dark. */
@media screen and ( prefers-color-scheme: dark ) {
html.skin-theme-clientpref-os {
--color-base: #ccd1d6;
--color-emphasized: #dfe3e7;
--color-subtle: #9fa6ae;
--background-color-base: #17191c;
}
}

/* A single external link styled as a button, for the one place that needs it:
the database dump on OpenJournal:Helping out. */
.oj-download {
margin: 1em 0;
}

.oj-download a {
display: inline-block;
padding: 0.55em 1.1em;
border-radius: 2px;
background: var( --background-color-progressive, #36c );
color: var( --color-inverted, #fff );
font-weight: 600;
text-decoration: none;
}

.oj-download a:hover {
background: var( --background-color-progressive--hover, #4b77d6 );
}

/* MediaWiki marks every external link with a small icon by default; it reads
oddly against a button. */
.oj-download a.external {
background-image: none;
padding-right: 1.1em;
}

/* Prev/next links at the bottom of each page of the front-page feed. */
.oj-pager {
display: flex;
justify-content: space-between;
margin-top: 1em;
padding-top: 0.6em;
border-top: 1px solid var( --border-color-muted, #eaecf0 );
font-size: 0.92em;
}

/* Either link can be absent (first or last page). flexbox alone can't tell
"only Older present" from "only Newer present" -- both are a lone
first-child -- so the template gives Older its own class to push right. */
.oj-pager .oj-older {
margin-left: auto;
}

/* Appearance (theme/font-size/width) is removed from every page rather than
relocated -- Vector wires it into the right column with no config to move
it, and Special:Preferences already has a real, working "Color" setting
under Appearance, so nothing is lost for anyone with an account; readers
without one still get the site's OJ_DEFAULT_THEME default. */
.vector-appearance-landmark {
display: none;
}

/* "Switch to old look" (legacy Vector opt-out), shown to logged-in users at
the bottom of the left menu. Vector hardcodes this with no config flag to
turn it off -- confirmed by rendering the component directly rather than
guessing from the template -- so it's removed the same way as Appearance. */
.vector-main-menu-action-opt-out {
display: none;
}

/* The right panel's "Last modified" link already says this. No config gate
exists for the footer's own copy (unlike Privacy/About/Disclaimers just
above, which are disabled the proper way, via their interface messages),
so it's hidden the same way Appearance and the old-look link are. */
#footer-info-lastmod {
display: none;
}

/* Vector deliberately gives the page title (h1) and h2 section headings a
serif font -- Wikipedia's own visual identity -- while body text, and
even h3-h6, stay sans-serif. Confirmed in skins.vector.styles: the rule
is .mw-body h1, .mw-body-content h1/h2 { font-family: 'Linux Libertine' ...
That split reads as inconsistent here, so headings inherit the body font
instead of overriding it -- one font, everywhere, and it stays that way
even if the body font ever changes. */
.mw-body h1,
.mw-body .mw-heading1,
.mw-body-content h1,
.mw-body-content .mw-heading1,
.mw-body-content h2,
.mw-body-content .mw-heading2 {
font-family: inherit;
}

OpenJournal:Seeded

2026-09-10T19:58:30Z

OpenJournalAdmin: seed marker

Seed data was loaded on 2026-09-10.

OpenJournal:Helping out

2026-09-10T19:58:29Z

OpenJournalAdmin: how to download a copy of the site

openjournal is nothing but MediaWiki, wikitext and Apache configuration -- every
article on this site can leave with you.

== Download the database ==

<div class="oj-download">
[{{SERVER}}/download/openjournal-latest.xml.gz Download the database dump]
</div>

That is a standard '''MediaWiki XML export''' -- the same format
[https://en.wikipedia.org/wiki/Wikipedia:Database_download Wikipedia's own public
dumps] use. It carries every article and every revision, attributed by username.
It does '''not''' carry passwords, email addresses, or anything else about accounts
-- that is the whole reason this format exists, separately from a raw database
backup, and it is why it is safe to download and pass around.

It is a snapshot, refreshed by hand rather than live, so it can lag behind the
site by a while. If you want the current moment instead of the last snapshot, the
[[OpenJournal:API|API]] reads straight from the live wiki.

== What to do with it ==

Anyone running their own MediaWiki can load the file directly:

* through the browser, at '''Special:Import''' -- or
* from the command line: <code>php maintenance/run.php importDump openjournal-latest.xml.gz</code>

Either way you end up with your own copy of every article here, on your own wiki,
under your own control. Nothing about openjournal is required to read it further
than that.

== Anything else ==

This page exists because someone asked for exactly this: a way to take the data
and go. If there is a different kind of help that would actually be useful --
writing, fixing something, saying what is missing -- '''Discussion''' on this page
reaches whoever maintains the site.

OpenJournal:Authors

2026-09-10T19:58:29Z

OpenJournalAdmin: list of every author

Everyone who writes on openjournal. Follow a name to read their journal.

{{#dpl:
|namespace = User
|nottitlematch = %/%
|ordermethod = title
|count = 200
|mode = userformat
|listseparators = <div class="oj-feed">,<div class="oj-entry">'''[[%PAGE%{{!}}%TITLE%]]'''</div>,,</div>
|allowcachedresults = false
|noresultsheader = <em>Nobody has started a journal yet.</em>
}}

----
<div class="oj-footnote">
A journal appears here once its author has created their
[[Special:MyPage|journal home]]. To browse every page instead, including each
individual article, see [[Special:PrefixIndex/User:|the full index]].
</div>

OpenJournal:API

2026-09-10T19:58:28Z

OpenJournalAdmin: API documentation

openjournal is MediaWiki, so it has MediaWiki's APIs — nothing here is bespoke, and
anything true of the [https://www.mediawiki.org/wiki/API:Main_page MediaWiki API] is
true here.

Cross-origin reads are allowed, so you can call these straight from a browser — but
MediaWiki only sends the CORS headers when you ask for them, so add
'''<code>&origin=*</code>''' to any <code>api.php</code> request you make from
another site. <code>rest.php</code> needs no such parameter.

Articles are subpages of their author: '''<code>User:Alice/Some title</code>'''. That
means "everything Alice wrote" is a title-prefix query.

== The friendly routes ==

For the common case -- get someone's posts, get one post -- these read better than
the MediaWiki API underneath them, which is all they are: Apache rewrite rules onto
the exact same <code>api.php</code> and <code>action=render</code> this page
documents further down, not a second API to keep in sync.

<pre>
GET /users/{username}/posts all of a user's posts, alphabetical by title
GET /users/{username}/posts/{title} one post: title, wikitext, last-edited time
GET /users/{username}/posts/{title}?format=html the same post, rendered to HTML
GET /users/{username} redirects to their journal (browsable)
</pre>

<code>{title}</code> is the part after the slash, with spaces as underscores, e.g.
<code>/users/Alice/posts/Laying_a_hedge</code> for
<code>User:Alice/Laying a hedge</code>.

A post that doesn't exist behaves differently depending on the format: with
<code>?format=html</code> you get a real <code>404</code>. Without it -- the default,
plain JSON -- you always get <code>200</code>, with <code>"missing":true</code> in the
body instead. That form is calling <code>api.php</code> underneath, and there is no
way to make MediaWiki's own API answer with a different HTTP status without writing
code, which
this project avoids. Check <code>missing</code> if that matters to you.

== All articles by one user (the underlying MediaWiki call) ==

Same data the <code>/users/{username}/posts</code> route above returns, and where
its extra parameters -- excerpts, URLs -- come from, if you want to add your own.

<pre>
GET /api.php?action=query&list=allpages&apnamespace=2&apprefix=Alice/&format=json
</pre>

== One article, as HTML ==

<pre>
GET /rest.php/v1/page/User%3AAlice%2FSome_title/html
</pre>

== One article, as source ==

<pre>
GET /rest.php/v1/page/User%3AAlice%2FSome_title
</pre>

== Every article on the site, newest first ==

<pre>
GET /api.php?action=query&generator=recentchanges&grcnamespace=2&grclimit=30&format=json
</pre>

== Excerpts and lead images, for a card or a feed ==

<pre>
GET /api.php?action=query&prop=extracts|pageimages&exchars=300&explaintext=1&titles=User:Alice/Some_title&format=json
</pre>

== An Atom feed of everything ==

<pre>
GET /index.php?title=Special:RecentChanges&feed=atom&namespace=2
</pre>

One author's feed is the same URL narrowed with <code>&tagfilter=</code> or, more
simply, poll <code>list=allpages</code> above.

== Writing from your own code ==

Editing over the API uses the same login you use in the browser, which is Wikimedia
OAuth — so a script writes by acting as you through an
[https://meta.wikimedia.org/wiki/Special:OAuthConsumerRegistration owner-only OAuth
consumer], not by sending a password. Bot passwords are switched off here for the
same reason.

See [[OpenJournal:API/Recipes]] for worked examples, or the full parameter reference
at [[Special:ApiHelp/query]] — it is generated from this wiki's own installed modules,
so it is never out of date.

OpenJournal:Latest articles

2026-09-10T19:58:28Z

OpenJournalAdmin: every article, 50 per page

Every article on openjournal, newest first, 50 to a page.

{{Latest articles page|offset=0|count=50}}

OpenJournal:Latest/4

2026-09-10T19:58:27Z

OpenJournalAdmin: page 4 of the front-page feed

OpenJournal:Latest/3

2026-09-10T19:58:26Z

OpenJournalAdmin: page 3 of the front-page feed

{{Latest articles page|offset=20|prev=OpenJournal:Latest/2|next=OpenJournal:Latest/4}}

OpenJournal:Latest/2

2026-09-10T19:58:26Z

OpenJournalAdmin: page 2 of the front-page feed

{{Latest articles page|offset=10|prev=Main Page|next=OpenJournal:Latest/3}}

Main Page

2026-09-10T19:58:25Z

OpenJournalAdmin: openjournal front page

<div class="oj-hero">
<div class="oj-hero-title">openjournal</div>
<div class="oj-hero-sub">
Welcome to openjournal!

A fully open blogging platform.

Start writing immediately and join the community!

Some handy things to know:

- The visual editor supports both Markdown and wiktext*

Want to write on here but host your posts elsewhere?

Read our API Guide

Wikitext is very powerful and native to openjournal so it's recommended you use it and learn it.

You can read about it here:

https://en.wikipedia.org/wiki/Help:Wikitext

Happy writing!
</div>

== Latest articles ==

{{Latest articles page|offset=0|next=OpenJournal:Latest/2}}

== Everyone writing here ==

{{#dpl:
|namespace = User
|nottitlematch = %/%
|ordermethod = title
|count = 100
|mode = userformat
|listseparators = <span class="oj-authors">,<span>[[%PAGE%{{!}}%TITLE%]]</span>,,</span>
|allowcachedresults = false
}}

== Wanting to help out? ==

openjournal is nothing but MediaWiki underneath, which means everything on it can
leave with you -- see [[OpenJournal:Helping out]] for a database dump you can
download and load into a wiki of your own.

MediaWiki:Dpl-parserfunc-tracking-category

2026-09-10T19:58:24Z

OpenJournalAdmin: stop DPL's own tracking category showing up

MediaWiki:Dpl-tracking-category

2026-09-10T19:58:24Z

OpenJournalAdmin: stop DPL's own tracking category showing up

MediaWiki:Disclaimers

2026-09-10T19:58:23Z

OpenJournalAdmin: disable the broken Disclaimers footer link

MediaWiki:Aboutsite

2026-09-10T19:58:23Z

OpenJournalAdmin: disable the broken About footer link

MediaWiki:Privacy

2026-09-10T19:58:22Z

OpenJournalAdmin: disable the broken Privacy policy footer link

MediaWiki:Openjournal-write-in-your-journal

2026-09-10T19:58:22Z

OpenJournalAdmin: off-limits message

This part of openjournal is not a page anyone can write in — the front page,
templates and site documentation are looked after by the site's maintainers.

Your own writing goes in your journal, at <code>User:''You''/''Title''</code>.
Head to [[Special:MyPage|your journal]] to start an article, and use the
'''Discussion''' tab if you want to raise something about this page.

MediaWiki:Openjournal-not-your-journal

2026-09-10T19:58:21Z

OpenJournalAdmin: ownership message

This article belongs to [[User:$1|$1]]'s journal, so only $1 can edit it.

You can still join the conversation on its '''Discussion''' tab, or write about it in
[[Special:MyPage|your own journal]].

MediaWiki:Sidebar

2026-09-10T19:58:20Z

OpenJournalAdmin: openjournal navigation

Template:Latest articles page

2026-09-10T19:58:20Z

OpenJournalAdmin: one page of the front-page feed

<noinclude>
One page of the "Latest articles" feed on the front page. Takes a literal, hardcoded
offset rather than reading one from the URL: DPL's own offset-caching does not vary
by query string, so two different offsets requested close together can otherwise
serve each other's cached page -- confirmed the hard way, not a hypothetical. A
handful of separate, ordinary wiki pages, each pinned to its own offset, has no such
problem, at the cost of being a fixed number of pages rather than infinite scroll.

Parameters: '''offset''' (required), '''prev''' and '''next''' (page titles, omit
whichever end doesn't apply), '''count''' (articles per page, default 10).

To add a page once there is enough new content: create the next page with
<code>offset</code> higher than the last one by however many <code>count</code> is
for that feed, point its <code>prev</code> at the page before it, and set that
previous page's <code>next</code> to the new page.
</noinclude><includeonly><div class="oj-feed-page">
{{#dpl:
|namespace = User
|titlematch = %/%
|ordermethod = lastedit
|order = descending
|count = {{{count|10}}}
|offset = {{{offset}}}
|mode = userformat
|listseparators = <div class="oj-feed">,<div class="oj-entry">'''[[%PAGE%{{!}}%TITLE%]]'''<br /><span class="oj-byline">by [[User:%USER%{{!}}%USER%]] · %DATE%</span></div>,,</div>
|replaceintitle = /^[^\/]*\//,
|addauthor = true
|addeditdate = true
|allowcachedresults = false
|noresultsheader = <em>No more articles.</em>
}}
<div class="oj-pager">{{#if:{{{prev|}}}|<span class="oj-newer">[[{{{prev}}}|← Newer articles]]</span>}}{{#if:{{{next|}}}|<span class="oj-older">[[{{{next}}}|Older articles →]]</span>}}</div>
</div></includeonly>

Template:Article/preload

2026-09-10T19:58:19Z

OpenJournalAdmin: skeleton for new articles

<noinclude>Skeleton loaded into every new openjournal article.</noinclude><includeonly></includeonly>Write your article here, then delete this.

Markdown works as you type:

* <nowiki>**bold**</nowiki> or <nowiki>__bold__</nowiki>, <nowiki>*italics*</nowiki> or <nowiki>_italics_</nowiki>,
<nowiki>`code`</nowiki> and <nowiki>~~strikethrough~~</nowiki> format themselves once you close them
* <nowiki># </nowiki> to <nowiki>###### </nowiki> at the start of a line make headings
* <nowiki>- </nowiki> or <nowiki>* </nowiki> starts a bullet list, <nowiki>1. </nowiki> a numbered one
* <nowiki>> </nowiki> quotes, <nowiki>```</nowiki> opens a code block, <nowiki>---</nowiki> draws a rule

These are typing shortcuts, so they only apply in the visual editor — the one
this button opened. Under "Edit source" you are writing wikitext, where bold is
<nowiki>'''three quotes'''</nowiki> and Markdown characters stay as you typed them.

When you save, this article appears on the [[Main Page|front page]] and in your
journal, and anyone logged in can reply on its '''Discussion''' tab.

Template:Journal

2026-09-10T19:58:19Z

OpenJournalAdmin: journal home template

<noinclude>
Put <code><nowiki>{{Journal}}</nowiki></code> on your user page to turn it into your journal home:
it lists your articles and gives you a box for starting a new one.
</noinclude><includeonly><div class="oj-journal">
<inputbox>
type=create
prefix={{FULLPAGENAME}}/
buttonlabel=Start a new article
placeholder=Title of your next article
preload=Template:Article/preload
useve=true
break=no
</inputbox>

{{#dpl:
|namespace = User
|titlematch = {{PAGENAME}}/%
|ordermethod = lastedit
|order = descending
|count = 100
|mode = userformat
|listseparators = <div class="oj-feed">,<div class="oj-entry">'''[[%PAGE%{{!}}%TITLE%]]''' <span class="oj-byline">· %DATE%</span></div>,,</div>
|replaceintitle = /^[^\/]*\//,
|addeditdate = true
|noresultsheader = <em>No articles here yet.</em>
|allowcachedresults = false
}}
</div></includeonly>