Coursewright
Write your course in markdown, in your own editor, with git underneath. Publish
it as a website for your students, hand it out as a styled PDF or DOCX, or sync
it straight into Canvas LMS, whichever you need. Bundled AI skills pitch in on
lesson design, module building and proofreading when you ask. Both the AI and
Canvas are optional: your course is plain files, and it works without either.
Course material tends to live wherever it was last edited: an LMS editor, a Word
file, a slide deck. Maintaining a whole course that way means losing history,
search and replace, and any review of changes before students see them.
Coursewright moves the source of truth to plain markdown files on your computer,
and every output is built from that one source: the website, the handout, the
Canvas modules.
The suggested workflow has a didactic backbone: backward design and constructive
alignment. Learning goals come first, then the assessment that evidences them,
then the lessons; the skills read that chain from one file, check your material
against it, and a retro folds what happened in class back into next year's plan.
It is a proven base that never becomes a straitjacket: every structure is a
default your own conventions override. The reasoning is in
didactic foundations.
What You Get
- Your own tools. Write in VS Code or any editor, keep everything in git,
and review every change before it goes live.
- Instant preview, publishable. A local website
(Docusaurus) shows your course as you write, in the
same structure students will see. One GitHub setting
publishes it as a public course website, and any static
host can serve the same build. The tool's own site,
coursewright.md, is the built-in tutorial module
published this way.
- PDF and DOCX export. Hand out a styled course text or a single chapter,
with your institution's branding. See exporting.
- A VS Code extension. Every command is reachable from the sidebar or the
command palette, so daily work needs no terminal. The two destructive ones and
the glossary builder are palette-only, kept out of the tree so no stray click
can start them. What the panel does not reach is flags, not commands.
- One-command Canvas sync.
npx course sync reconciles modules, pages,
assignments, discussions and files with
Canvas LMS in both directions, and
deletes nothing unless you ask. push and pull are the same run with the
direction pinned, and status shows what a sync would do without doing it.
- AI-assisted authoring on didactically sound foundations. Bundled skills
help design lessons, build student modules, generate Canvas quizzes,
proofread, and check course consistency, with any AI coding agent that reads
AGENTS.md. The lesson workflow shows how they
chain from idea to published module.
- A template that stays updatable. Create your course from this template and
keep pulling tooling improvements later; your course content is never
overwritten.
What It Does Not Do
Worth knowing before you commit a semester to it. Every entry here is about the
Canvas sync, because that is where the surprises live; the website and the
export have far less small print, and limitations opens
with their short list.
- Not every type syncs as content. Pages, assignments, discussions and files
live in your markdown and are rebuilt from it. A quiz and an external tool
(LTI) sync as references: the file says which Canvas object goes where in a
module, and push never creates or changes the object itself.
- Quiz questions never sync. A bundled skill generates a QTI package you
import into Canvas by hand, once, in one direction.
- A push makes your markdown win. It reconciles a module item by item, so
anything you added by hand in Canvas stays where it is. But a Canvas object
whose type and title match a local file is claimed by that file, and from then
on the file decides what it holds.
- The folder layout is a contract: one folder per module, one level of
nesting, numbered prefixes.
- Nothing merges two versions of one item. A sync decides which side wins
and writes that copy whole; it never blends the two. Git is the undo, which is
why a local file holding uncommitted work is never written over, and only
pull --force overrides that.
The full list, with what to do instead, is in
limitations. Before pointing it at a course that already
has content, read backups.
Who It's For
Lecturers and teaching teams who want course material in files, folders and
version control, whatever it ends up published to: a course website, a printed
reader, Canvas, or all three. You don't need to be technical:
your first course starts from a computer with nothing
installed, and there is a git and GitHub guide for
complete beginners. The project has many other files; day to day, only
course/, sources/, context/, evaluations/ and README.md are yours to
edit.
Quick Start
New to this? Your first course, step by step goes
from a computer with nothing installed to a published course, assuming no
experience with VS Code, the terminal, or git.
The short version, if you have done this sort of thing before:
This is the beginning of the README. Read the rest at the original. Read the full README ↗
