Everything you need to build.

<writer-editor
  id="editor"
  mode="wysiwyg"
  theme="serif-editorial"
  scheme="light"
  locale="en"
  placeholder="Write…"
  toolbar="true"
  statusbar="true"
></writer-editor>

import { createWriter, parse, stringify } from '@writer/core';

const writer = createWriter({
  markdown: '# Hello\n',
  gfm: true,
  html: 'sanitize',
  typography: 'serif-editorial',
});

writer.toHTML();          // HTML string
writer.toIR();            // WriterNode (document)
writer.toJSON(true);      // pretty JSON
writer.toMarkdown();      // normalized Markdown
writer.toText();          // plain text

const ir = parse('**hi**');        // Markdown → IR
const md = stringify(ir);          // IR → Markdown

import { WriterRender } from '@writer/core';

const html = WriterRender(markdown)
  .theme('serif-editorial')
  .variables({ '--wr-content-max-width': '60rem' })
  .asHTML();

const ir   = WriterRender(markdown).asIR();
const json = WriterRender(markdown).asJSON({}, true);
const md   = WriterRender(markdown).asMarkdown();
const text = WriterRender(markdown).asText();
const pdf  = await WriterRender(markdown).asPDF();

{
  "type": "document",
  "children": [
    {
      "type": "heading",
      "depth": 2,
      "children": [{ "type": "text", "value": "Hello" }]
    },
    {
      "type": "paragraph",
      "children": [
        { "type": "text", "value": "Use " },
        { "type": "strong", "children": [{ "type": "text", "value": "bold" }] },
        { "type": "text", "value": "." }
      ]
    }
  ]
}

import { createWriter, THEMES } from '@writer/core';

const writer = createWriter({ typography: 'serif-editorial' });

writer.typography.setTheme('technical');
const vars = writer.typography.variables();
const css  = writer.typography.toCss('article');
const scale = writer.typography.scale();

console.log(THEMES); // default, serif-editorial, technical, compact, magazine

writer-editor {
  --wr-font-sans: "Inter", system-ui, sans-serif;
  --wr-color-accent: #0b5fd7;
  --wr-content-max-width: 62rem;
  --wr-radius: 10px;
}

const matches = writer.css.detect({
  classes: ['container', 'row', 'col-md-6']
});

const classes = writer.css.gridClasses(
  { columns: 12, framework: 'bootstrap' },
  'bootstrap'
);

const container = writer.css.buildGrid({
  columns: 12,
  framework: 'bootstrap',
  rows: [[
    { content: 'A', span: 6 },
    { content: 'B', span: 6 }
  ]]
});

const issues = writer.css.lint(writer.doc);

const table = writer.tables.create({
  rows: 2,
  columns: 3,
  header: true
});

const wider = writer.tables.insertColumn(table, 1);
const csv   = writer.tables.toCsv(wider);

writer.apply(() => writer.tables.setAlign(wider, 2, 'right'));

const session = writer.tables.session(table.id);
session.focusCell(0, 1);

import {
  createWriter,
  createMemoryProvider,
  createServerProvider,
} from '@writer/core';

const writer = createWriter();

writer.media.register(createMemoryProvider({ '/logo.svg': '<svg/>' }, 'demo'));

writer.media.register(createServerProvider({
  id: 'cdn',
  endpoint: 'https://api.example.com/media',
  remote: 'assets',
  auth: async () => ({ Authorization: `Bearer ${await getToken()}` }),
}));

writer.media.use('cdn');

<writer-media-manager
  open
  provider="cdn"
  path="/uploads"
  accept="image/*"
  multiple
  title="Media library"
></writer-media-manager>

const manager = document.querySelector('writer-media-manager');

manager.writer = createWriter({ media: [provider] });

manager.addEventListener('wr-media-select', (event) => {
  const [entry] = event.detail.entries;
  const markdown = manager.writer.media.toMarkdown(entry, {
    alt: entry.name,
  });
  console.log(markdown);
});

GET    {base}?action=list&provider={id}&path={path}
GET    {base}?action=stat&provider={id}&path={path}
GET    {base}?action=url&provider={id}&path={path}
GET    {base}?action=read&provider={id}&path={path}
GET    {base}?action=search&provider={id}&q={query}
POST   {base}?action=upload&provider={id}&path={path}
POST   {base}?action=mkdir&provider={id}&path={path}
POST   {base}?action=move&provider={id}&from={p}&to={p}
POST   {base}?action=copy&provider={id}&from={p}&to={p}
DELETE {base}?action=delete&provider={id}&path={path}

<?php
use Writer\Media\MediaManager;
use Writer\Media\LocalProvider;
use Writer\Server\MediaEndpoint;

$media = new MediaManager();
$media->register(new LocalProvider('/var/www/uploads', 'uploads'));

$endpoint = new MediaEndpoint($media, $responseFactory, [
    'tokens' => ['secret-bearer-token'],
]);

$response = $endpoint->handle($request);

from writer.media import MediaManager, LocalProvider
from writer.server import media_router

media = MediaManager()
media.register(LocalProvider("/var/www/uploads", "uploads"))

router = media_router(media, tokens=["secret-bearer-token"])

try {
  const result = await WriterRender(markdown).asPDF({
    page: { size: 'A4' },
    metadata: { title: 'Report' },
  });
  // result.contents: base64 PDF
} catch (error) {
  if (error.code === 'NO_PDF_ENGINE') {
    // Fallback: standalone print HTML
    const print = WriterRender(markdown).asHTML({
      standalone: true,
      embedCss: true,
    });
  }
}

$pdf = WriterRender($markdown)->asPDF();

header('Content-Type: application/pdf');
header('Content-Disposition: attachment; filename="document.pdf"');
echo $pdf;

pdf = WriterRender(markdown).as_pdf()
# bytes — start with b"%PDF-"

with open("document.pdf", "wb") as handle:
    handle.write(pdf)

<?php
require 'vendor/autoload.php';

use Writer\Writer;

$html = WriterRender($markdown)->asHTML();
$ir   = WriterRender($markdown)->asIR();
$json = WriterRender($markdown)->asJSON(true);
$md   = WriterRender($markdown)->asMarkdown();
$pdf  = WriterRender($markdown)->asPDF();

$writer = Writer::create(['gfm' => true, 'theme' => 'technical']);
$result = $writer->render('# Hi', 'html');
echo $result->contents();

from writer import WriterRender, Writer, render

html = WriterRender("# Hello").as_html()
ir   = WriterRender("Hello *world*").as_ir()
json = WriterRender("# Hello").as_json(pretty=True)
md   = WriterRender("# Hello").as_markdown()
pdf  = WriterRender("# Hello").as_pdf()

result = Writer.render("# Hello", format="html")
same = render("# Hello", "html")

writer = Writer.create({"gfm": True, "theme": "technical"})
print(writer.to_html())

const markdown = editor.getMarkdown();

await fetch('/api/render', {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ markdown }),
});

<?php
require 'vendor/autoload.php';

$body = json_decode(file_get_contents('php://input'), true);
$markdown = $body['markdown'] ?? '';

header('Content-Type: text/html; charset=utf-8');
echo WriterRender($markdown)->asHTML([
    'standalone' => false,
]);

const snapshot = writer.toJSONSnapshot();
localStorage.setItem('writer:draft', JSON.stringify(snapshot));

const saved = JSON.parse(localStorage.getItem('writer:draft'));
const restored = createWriter({ document: saved.document });

writer.commands.register({
  id: 'insert.signature',
  label: 'Insert signature',
  group: 'insert',
  run(ctx) {
    ctx.setSource(ctx.source + '\n\n— Writer');
    return true;
  },
});

import type { WriterPlugin } from '@writer/core';

const upper: WriterPlugin = {
  name: 'upper',
  render: {
    text(_ctx, output) {
      return String(output).toUpperCase();
    },
  },
};

const writer = createWriter({ plugins: [upper] });

<script
  src="/assets/writer/0.2.0/writer.min.js"
  integrity="sha384-…"
  crossorigin="anonymous"
></script>