gtcode
Aloha gang,
Did one for fun, just to pass the time. Fount is an Elixir poncho repo containing screenplay writing and analysis tools. All MIT licensed, and thus fit for strip-mining or assimilation into your borg via your agentic initiatives:
A screenplay revision workshop for writers who want to experiment aggressively without losing control of the draft.
Fount lets you experiment aggressively with a screenplay without losing control of it: ask creative questions, generate real alternate pages, trace the consequences of big story changes, mix the best pieces, hear them performed, compare them to your draft, and decide what actually becomes canon.
It is built around a simple idea: rewriting a screenplay should not mean handing the whole script to a model and hoping it remembers what matters.
Fount keeps the screenplay itself, its revision history, its characters, scenes, dialogue, story evidence, alternate approaches, proposed changes, and accepted draft separate enough that you can try dangerous ideas without endangering the version you already have.
Nothing becomes part of the accepted screenplay merely because an AI generated it.
What You Can Actually Do With It
Fount is designed for screenplay work such as:
- Develop pages from a brief. Start with a dramatic intention, situation, constraint, or story problem and generate actual screenplay material rather than another outline about what could happen.
- Continue a draft or bridge existing scenes. Write forward from existing pages or create the missing dramatic connection between two scenes while using the surrounding screenplay as context.
- Explore genuinely different versions. Ask for multiple dramatic approaches, keep them as separate candidates, and audition the alternatives instead of forcing the system to choose one for you.
- Combine the best parts of different attempts. Keep the entrance from one version, the confrontation from another, a passage from a third, and generate only the connective writing needed to make those choices work together.
- Change a major story decision and repair the consequences. Move a reveal. Change who knows a secret. Remove an event. Alter a choice. Then inspect what earlier and later scenes depended on the old version and repair the affected material.
- Rebuild a sequence. Replace a weak run of scenes with a new dramatic progression while preserving the facts, passages, starting conditions, ending conditions, or outcomes that still need to survive.
- Rewrite a character across the draft. Change not just dialogue but choices, tactics, behavior, presence, relationships, and how other characters respond, while protecting story facts that should remain unchanged.
- Turn notes into coordinated revisions. Apply a small note locally or let a larger note produce related changes across scenes. Conflicting or unresolved notes can remain visible rather than being silently flattened into a rewrite.
- Run creative passes. Work specifically on subtext, tension, visual action, dialogue, exposition, compression, character behavior, rhythm, or another declared creative direction.
- Recover earlier writing. Find useful material from an older revision and either restore it or adapt it to the screenplay as it exists now.
- Investigate before rewriting. Ask where a story problem actually begins, whether a reveal happens too early, what depends on a scene you want to cut, whether a payoff has enough setup, whether two characters sound alike, or why a scene is not producing the intended dramatic effect.
- Hear the script. Turn screenplay dialogue into ordered table-read material with character voice mapping and pluggable speech synthesis.
- Compare before committing. Inspect screenplay changes, structural differences, reports, candidate pages, and PDFs before choosing what belongs in the accepted draft.
- Export screenplay PDFs and perform mechanical submission checks. Render candidate or accepted pages, inspect the resulting PDF, and run dated submission-oriented checks without pretending that a mechanical check replaces reading the screenplay.
The fount repo above has handoff docs for unfinished features, but there’s a superseding, more ambitious set of planned features in an complete implementation docset that you can use here:
Have fun.
Trending in Announcing
Other Trending Topics
Categories:
Sub Categories:
Forums
Popular Tags
- #ecto
- #liveview
- #troubleshooting
- #learning-elixir
- #library
- #deployment
- #erlang
- #testing
- #genserver
- #mix
- #absinthe
- #remote-other
- #otp
- #plug
- #how-to-question
- #macros
- #postgres
- #elixirconf
- #channels
- #exunit
- #discussion
- #code-sync
- #podcasts
- #javascript
- #onsite
- #dialyzer
- #docker
- #authentication
- #umbrella
- #full-time-contract
- #podcasts-by-brainlid
- #ai
- #ecto-query
- #elixirconf-us
- #blog-post
- #elixir-ls
- #phoenix_html
- #iex
- #graphql
- #genstage
- #websockets
- #supervisor
- #advent-of-code
- #distillery
- #processes
- #elixirconf-eu
- #api
- #forms
- #metaprogramming
- #hex










Most Liked- Show Best Posts
- Show All (oldest first)
- Show All (newest first)
alvinkatojr
Oh wow! You’ve been chunking out goodies nonstop. Wasn’t it last week that you released the TypeSafe SDK?
Fount looks great, but with the way the README.md is written, chances are that it’s only you who’ll be able to get this thing running locally. We need better docs: setup, installation, running, and usage(demos and examples).
Last Post!
gtcode
Thanks. Yeah, me and about 34 others built Jev related libs or integrations! I’m bogged down trying to build a little ecosystem of self hosted “system one” models, just low on inference to do it right. Plans are ready to run, I just don’t have inference and you really need a 20x codex or claude code sub to do this sort of development efficiently.
The screenplay thing is much simpler since its not “infrastructure”, just an app. It’s fun, and is a good way to showcase Elixir for use cases beyond infrastructure or real time.
Oh, unrelated, mostly – someone named deepfates is making a proper DSPy port called ‘imp’ – looks promising. Mine is just a wrapper around the Python lib on a mickey mouse (single host only) process pooler and Python FFI.
Regarding ‘fount’ - Yes, AI docs are awful. My bad. I finished the 16 phases above and am now building an orchestrator and Phoenix UI.
Generally - I have many docsets that were never run because I don’t have a quiver of 20x OAI and Ant subs. There is one notable hack worth mentioning, and it’s how I built ‘fount’ - you can get an OAI business plan - two subs - and they give basically unlimited xhigh in chat. You just have to pass impl docsets and codebases into chat and have it spit back zip overlays and updated docs. Then pass that to your host agent to QA/debug/finish. Chat doesn’t have an Elixir runtime but it can write the code. Do a large project in phases - chat to build, codex to debug/qa, for each phase. It’s how the docset above (now finished) is structured. The busy work is passing the repomix’s/zip’s for the updated docset and codebase(s) back and forth between chat and codex. (Yes, this can be automated with playwright, but that’s against OAI terms).
Apologies for the digression. Hope this helps someone. You can build non-trivial Elixir apps this way on the cheapest OAI business sub (should still be $40 or $50 per month). It’s just cumbersome, that’s all. 5hr limits, switching accounts, and using their generous chatbot isn’t ergonomic. But the price is right.