Simon Willison's Weblog: glitch

Saying Bye to Glitch

2025-05-29T20:36:06+00:00

Pirijan, co-creator of Glitch - who stopped working on it six years ago, so has the benefit of distance:

Here lies Glitch, a place on the web you could go to write up a website or a node.js server that would be hosted and updated as you type. 🥀 RIP 2015 – 2025.

Pirijan continues with a poignant retrospective about Glitch's early origins at Fog Greek with the vision of providing "web development with real code that was as easy as editing a Google Doc". Their conclusion:

I still believe there’s a market for easy and fun web development and hosting, but a product like this needs power-users and enthusiasts willing to pay for it. To build any kind of prosumer software, you do have to be an optimist and believe that enough of the world still cares about quality and craft.

Glitch will be shutting down project hosting and user profiles on July 8th.

Code will be available to download until the end of the year. Glitch have an official Python export script that can download all of your projects and assets.

Jenn Schiffer, formerly Director of Community at Glitch and then Fastly, is a little more salty:

all that being said, i do sincerely want to thank fastly for giving glitch the opportunity to live to its 3-year acqui-versary this week. they generously took in a beautiful flower and placed it upon their sunny window sill with hopes to grow it more. the problem is they chose to never water it, and anyone with an elementary school education know what happens then. i wish us all a merry august earnings call season.

I'm very sad to see Glitch go. I've been pointing people to my tutorial on Running Datasette on Glitch for 5 years now, it was a fantastic way to help people quickly get started hosting their own projects.

Via lobste.rs

Tags: glitch, datasette, fastly

Over-engineering Secret Santa with Python cryptography and Datasette

2022-12-11T02:03:39+00:00

We're doing a family Secret Santa this year, and we needed a way to randomly assign people to each other without anyone knowing who was assigned to who.

I offered to write some software! (Maybe "insisted" is more accurate)

I've been wanting an excuse to write something fun involving Python's cryptography library for years. The problem is that I'm too responsible/cowardly to ignore the many warnings to only use the "hazardous materials" area of that library if you know exactly what you're doing.

A secret santa is the perfect low stakes project to ignore those warnings and play with something fun.

My requirements

I have six participants. Each participant needs to know who they are to buy a gift for - with no way of finding out any of the other gift pairings.

As the administrator of the system I must not be able to figure out the pairings either.

I don't want to use email or logins or anything like that - I just want to be able to share a link in the family WhatsApp group and have everyone use the same interface to get their pairing.

How it works

Here's the scheme I came up with:

Each participant gets a password generated for them. This happens on demand when they click a button - with an honour system not to click someone else's button (easily detected since each button can only be clicked once). If someone DOES click someone else's button we can reset the entire system and start again.
Their password is generated for them - it's three random words, for example "squirrel copper sailboat". I expect most people to take a screenshot with their phone to record it.
Behind the scenes, each user has a RSA public/private key generated for them. The private key is encrypted using their new password, then both keys are stored in the database. The password itself is NOT stored.
Once every user has generated and recorded their password, we can execute the Secret Santa assignments. This shuffles the participants and then assigns each person to the person after them in the list. It then uses their public keys to encrypt a message telling them who they should buy a gift for.
Those encrypted messages are stored in the database too.
Finally, each user can return to the site and enter their password to decrypt and view their message.

And here's an animated GIF demo:

Building it as a Datasette plugin

This is a tiny app with a very small amount of persistence needed, so I decided to build it as a Datasette plugin on top of a couple of SQLite database tables.

In addition to giving me an excuse to try something new with my main project, this should also hopefully make it easy to deploy.

Most of the code is in the datasette_secret_santa/__init__.py file. I used a number of different plugin hooks:

startup() to create the database tables it needs when the server first starts (if they do not exist already)
canned_queries() to add a canned SQL query for creating new Secret Santa groups, to save me from needing to build a custom UI for that
register_routes() to register five new custom pages within Datasette
extra_template_vars() to make an extra context variable available on the Datasette homepage, which is rendered using a custom template

Here are the routes:

@hookimpl
def register_routes():
    return [
        (r"^/secret-santa/(?P<slug>[^/]+)$", secret_santa),
        (r"^/secret-santa/(?P<slug>[^/]+)/add$", add_participant),
        (r"^/secret-santa/(?P<slug>[^/]+)/assign$", assign_participants),
        (r"^/secret-santa/(?P<slug>[^/]+)/set-password/(?P<id>\d+)$", set_password),
        (r"^/secret-santa/(?P<slug>[^/]+)/reveal/(?P<id>\d+)$", reveal),
    ]

/secret-santa/{slug} is the main page for a Secret Santa group. It shows a list of participants and a form to add a new participant.
/secret-santa/{slug}/add is the endpoint for a form that adds a new participant.
/secret-santa/{slug}/set-password/{id} is the page that lets a user generate and retrieve their password.
/secret-santa/{slug}/reveal/{id} is the page where a user enters their password to reveal their Secret Santa assignment.
/secret-santa/{slug}/assign is the endpoint that does the work of assigning participants to each other, and generating and saving encrypted message for each of them.

The cryptography

The earlier warning holds firm here: I am not a cryptographer. I'm just having fun. You should not imitate any of the code I wrote here without thoroughly reviewing it with someone who knows what they're doing.

(I also used ChatGPT to write my first drafts of it, as described in this issue. Trusting cryptographic code generated by a large language model is a particularly bad idea!)

Disclaimers out of the way, here's the code I wrote to generate and store the RSA keys:

async def generate_password_and_keys_for_user(db, participant_id):
    password = " ".join(random.sample(words, 3))

    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
    public_key = private_key.public_key()

    # Serialize the keys for storage
    private_key_serialized = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.BestAvailableEncryption(
            password.encode("utf-8")
        ),
    ).decode("utf-8")
    public_key_serialized = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo,
    ).decode("utf-8")

    await db.execute_write(
        """
        update secret_santa_participants
        set
            password_issued_at = datetime('now'),
            public_key = :public_key,
            private_key = :private_key
        where id = :id
        """,
        {
            "id": participant_id,
            "public_key": public_key_serialized,
            "private_key": private_key_serialized,
        },
    )
    return password

As you can see, it uses rsa.generate_private_key() from the PyCA cryptography library to generate the public and private keys.

The options public_exponent=65537, key_size=2048 are recommended by the generate_private_key() documentation.

It then serializes them to PEM format strings that can be stored in the database.

The private key is serialized after being encrypted using the randomly generated password for that user. This produces a string that looks like this:

-----BEGIN ENCRYPTED PRIVATE KEY-----
...
-----END ENCRYPTED PRIVATE KEY-----

I had originally come up with my own scheme for this, involving AES encryption and a key derived from a hash of the raw password (which I planned to later run through bcrypt a few hundred thousand times) - I was very happy when I realized that there was a standard way to do this already.

The code that then assigns the participants and generates their encrypted messages looks like this:

# Assign participants
random.shuffle(participants)
for i, participant in enumerate(participants):
    assigned = participants[(i + 1) % len(participants)]
    message = "You should buy a gift for {}".format(assigned["name"])
    # Encrypt the message with their public key
    public_key = serialization.load_pem_public_key(
        participant["public_key"].encode("utf-8"), backend=default_backend()
    )
    secret_message_encrypted = public_key.encrypt(
        message.encode("utf-8"),
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None,
        ),
    )
    await db.execute_write(
        """
        update secret_santa_participants
        set secret_message_encrypted = :secret_message_encrypted
        where id = :id
        """,
        {
            "id": participant["id"],
            "secret_message_encrypted": secret_message_encrypted,
        },
    )

And finally, the code that decrypts the message when the user provides their password again:

data = await request.post_vars()
password = data.get("password", "").strip()
if not password:
    return await _error(
        datasette, request, "Please provide a password", status=400
    )
# Decrypt the private key with the password
try:
    private_key = decrypt_private_key_for_user(participant, password)
except ValueError:
    return await _error(datasette, request, "Incorrect password", status=400)
# Decrypt the secret message with the private key
decrypted_message = private_key.decrypt(
    participant["secret_message_encrypted"],
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None,
    ),
).decode("utf-8")

And some snowflakes

I spent all of five minutes on the visual design for it - the main feature of which is a thick red top border on body followed by a thinner white border to make it look like its wearing a Santa hat.

I did add some animated snowflakes though! I used this script Natalie Downe built back in 2010. It works great!

Deploying it on Glitch

This kind of project is a really great fit for Glitch, which offers free hosting with persistent file storage - perfect for SQLite - provided you don't mind your projects going to sleep in between bouts of activity (unless you pay to "boost" them). A Secret Santa app is a perfect fit for this sort of hosting.

(You can remix my project to get your own copy of the app (with your own database) by clicking the "Remix" button.)

Since I had shipped the plugin up to PyPI already, deploying it on Glitch was a matter of creating a new project there containing this single glitch.json file:

{
  "install": "pip3 install --user datasette datasette-secret-santa -U",
  "start": "datasette --create .data/santa.db -p 3000"
}

This causes Glitch to install both datasette and datasette-secret-santa when the project first launches. It then starts the Datasette server running like this:

datasette --create .data/santa.db -p 3000

The --create flag tells Datasette to create a new SQLite database if one doesn't already exist at that path. .data/ is a special directory on Glitch that won't have its contents automatically tracked using their version control.

The -p 3000 flag tells the server to listen on port 3000, which is the Glitch default - traffic to the subdomain for the app will automatically be routed to that port.

And the database is public

Here's a slightly surprising thing about this: the SQLite table containing all of the data - including the public keys and encrypted private keys - is visible for anyone with access to the instance to see!

Here's that table for a demo I deployed on Glitch.

Once again, I am by no means a cryptography expert, and this isn't something I would tolerate for any other application. But with the risk profile involved in a secret santa I think this is OK. I'm pretty sure you could brute force decrypt the private keys if you really wanted to, so it's a good thing they're not being used for anything else!

(This is also one of the reasons I didn't let users pick their own passwords - by assigning generated passwords I can be 100% sure I don't accidentally end up holding onto an encrypted copy of a credential that could be used for anything else.)

Self-contained apps as plugins

Something I find interesting about this project is that it demonstrates how a Datasette plugin can be used to provide a full, self-contained app.

I think this is a powerful pattern. It's a neat way to take advantage of the tools I've built to help make Datasette easy to deploy - not just on Glitch but on platforms like Fly as well.

This is my first time using Datasette in this way and I found it to be a pleasantly productive way of building and deploying this kind of personal tool. I'm looking forward to trying this approach out for other projects in the future.

And if you know cryptography and can spot any glaring (or subtle) holes in the way my system works, please open an issue and let me know!

Tags: cryptography, glitch, projects, datasette, chatgpt, llms, ai-assisted-programming

Datasette 0.31

2019-11-12T06:11:57+00:00

Datasette 0.31

Released today: this version adds compatibility with Python 3.8 and breaks compatibility with Python 3.5. Since Glitch support Python 3.7.3 now I decided I could finally give up on 3.5. This means Datasette can use f-strings now, but more importantly it opens up the opportunity to start taking advantage of Starlette, which makes all kinds of interesting new ASGI-based plugins much easier to build.

Tags: glitch, projects, python, datasette, asgi, starlette

Weeknotes: Python 3.7 on Glitch, datasette-render-markdown

2019-11-11T23:26:34+00:00

Streaks is really working well for me. I’m at 12 days of commits to Datasette, 16 posting a daily Niche Museum, 19 of actually reviewing my email inbox and 14 of guitar practice. I rewarded myself for that last one by purchasing an actual classical (as opposed to acoustic) guitar.

Datasette

One downside: since my aim is to land a commit to Datasette master every day, I’m incentivised to land small changes. I have a bunch of much larger Datasette projects in the works - I think my goal for the next week should be to land one of those. Contenders include:

TableView.data() refactor - a blocker on a bunch of other projects
Datasette Edit - finish the new connection work so I can have plugins that write changes to databases
Datasette Library - watch a directory and automatically serve new database files that show up in that directory
Finish and ship my work on facet-by-many-to-many
Implement basic join support for table views (so you can join without writing a custom SQL query)
Probably the most impactful: Datasette needs a website! Up until now I’ve directed people to GitHub or to the documentation but the project has grow to the point that it warrants its own home.

I’m going to redefine my daily goal to include pushing in-progress work to Datasette branches in an attempt to escape that false incentive.

New datasette-csvs using Python 3.7 on Glitch

The main reason I’ve been strict about keeping Datasette compatible with Python 3.5 is that it was the only version supported by Glitch, and Glitch has become my favourite tool for getting people up and running with Datasette quickly.

There’s been a long running Glitch support thread requesting an upgrade, and last week it finally bore fruit. Projects on Glitch now get python3 pointing to Python 3.7.5 instead!

This actually broke my datasette-csvs project at first, because for some reason under Python 3.7 the Pandas dependency used by csvs-to-sqlite started taking up too much space from the 200MB Glitch instance quota. I ended up working around this by switching over to using my sqlite-utils CLI tool instead, which has much lighter dependencies.

I’ve shared the new code for my Glitch project in the datasette-csvs repo on GitHub.

The one thing missing from sqlite-utils insert my.db mytable myfile.csv --csv right now is the ability to run it against multiple files at once - something csvs-to-sqlite handles really well. I ended up finally learning how to use while in bash and wrote the following install.sh shell script:

$ pip3 install -U -r requirements.txt --user && \
  mkdir -p .data && \
  rm .data/data.db || true && \
  for f in *.csv
    do
        sqlite-utils insert .data/data.db ${f%.*} $f --csv
    done

${f%.*} is the bash incantation for stripping off the file extension - so the above evaluates to this for each of the CSV files it finds in the root directory:

$ sqlite-utils insert .data/data.db trees trees.csv --csv

github-to-sqlite releases

I released github-to-sqlite 0.6 with a new sub-command:

$ github-to-sqlite releases github.db simonw/datasette

It grabs all of the releases for a repository using the GitHub releases API.

I’m using this for my personal Dogsheep instance, but I’m also planning to use this for the forthcoming Datasette website - I want to pull together all of the releases of all of the Datasette Ecosystem of projects in one place.

I decided to exercise my new bash while skills and write a script to run by cron once an hour which fetches all of my repos (from both my simonw account and my dogsheep GitHub organization) and then fetches their releases.

Since I don’t want to fetch releases for all 257 of my personal GitHub repos - just the repos which relate to Datasette - I started applying a new datasette-io topic (for datasette.io, my planned website domain) to the repos that I want to pull releases from.

Then I came up with this shell script monstrosity:

#!/bin/bash
# Fetch repos for simonw and dogsheep
github-to-sqlite repos github.db simonw dogsheep -a auth.json

# Fetch releases for the repos tagged 'datasette-io'
sqlite-utils github.db "
select full_name from repos where rowid in (
    select repos.rowid from repos, json_each(repos.topics) j
    where j.value = 'datasette-io'
)" --csv --no-headers | while read repo;
    do github-to-sqlite releases \
            github.db $(echo $repo | tr -d '\r') \
            -a auth.json;
        sleep 2;
    done;

Here’s an example of the database this produces, running on Cloud Run: https://github-to-sqlite-releases-j7hipcg4aq-uc.a.run.app

I’m using the ability of sqlite-utils to run a SQL query and return the results as CSV, but without the header row. Then I pipe the results through a while loop and use them to call the github-to-sqlite releases command against each repo.

I ran into a weird bug which turned out to be caused by the CSV output using \r\n which was fed into github-to-sqlite releases as simonw/datasette\r - I fixed that using $(echo $repo | tr -d '\r').

datasette-render-markdown

Now that I have a releases database table with all of the releases of my various packages I want to be able to browse them in one place. I fired up Datasette and realized that the most interesting information is in the body column, which contains markdown.

So I built a plugin for the render_cell plugin hook which safely renders markdown data as HTML. Here’s the full implementation of the plugin:

import bleach
import markdown
from datasette import hookimpl
import jinja2

ALLOWED_TAGS = [
    "a", "abbr", "acronym", "b", "blockquote", "code", "em",
    "i", "li", "ol", "strong", "ul", "pre", "p", "h1","h2",
    "h3", "h4", "h5", "h6",
]

@hookimpl()
def render_cell(value, column):
    if not isinstance(value, str):
        return None
    # Only convert to markdown if table ends in _markdown
    if not column.endswith("_markdown"):
        return None
    # Render it!
    html = bleach.linkify(
        bleach.clean(
            markdown.markdown(value, output_format="html5"),
            tags=ALLOWED_TAGS,
        )
    )
    return jinja2.Markup(html)

This first release of the plugin just looks for column names that end in _markdown and renders those. So the following SQL query does what I need:

select
  json_object("label", repos.full_name, "href", repos.html_url) as repo,
  json_object(
    "href",
    releases.html_url,
    "label",
    releases.name
  ) as release,
  substr(releases.published_at, 0, 11) as date,
  releases.body as body_markdown,
  releases.published_at
from
  releases
  join repos on repos.id = releases.repo
order by
  releases.published_at desc

In aliases releases.body to body_markdown to trigger the markdown rendering, and uses json_object(...) to cause datasette-json-html to render some links.

You can see the results here.

More museums

I added another 7 museums to www.niche-museums.com.

Dingles Fairground Heritage Centre
Ilfracombe Museum
Barometer World
La Galcante
Musée des Arts et Métiers
International Women’s Air & Space Museum
West Kern Oil Museum

Tags: glitch, museums, python, markdown, datasette, weeknotes, sqlite-utils

Get your own Pocket OAuth token

2019-10-05T21:56:38+00:00

Get your own Pocket OAuth token

I hate it when APIs make you jump through extensive hoops just to get an access token for pulling data directly from your own personal account. I’ve been playing with the Pocket API today and it has a pretty complex OAuth flow, so I built a tiny Flask app on Glitch which helps go through the steps to get an API token for your own personal Pocket account.

Via Source code for your-pocket-oauth-token.glitch.me

Tags: glitch, mozilla, oauth

Public Data Release of Stack Overflow’s 2019 Developer Survey

2019-05-21T18:51:43+00:00

Public Data Release of Stack Overflow’s 2019 Developer Survey

Here’s the Stack Overflow announcement of their developer survey public data release, which discusses the Glitch partnership and mentions Datasette.

Tags: glitch, stackoverflow, surveys, datasette

Discover Insights in Developer Survey Results

2019-05-21T18:50:22+00:00

Discover Insights in Developer Survey Results

Stack Overflow partnered with Glitch and used Datasette to host the full data set from Stack Overflow’s 2019 Developer Survey!

Tags: glitch, stackoverflow, surveys, datasette

Hello world for ASGI running on Glitch

2019-04-26T05:06:12+00:00

Hello world for ASGI running on Glitch

I’m continuing to experiment with Python 3 running on Glitch. This evening on my walk home from work I built this “hello world” demo on my phone, partly to see if Glitch was a workable mobile development environment—it passed with flying colours! The demo is a simple hello world implemented using the new ASGI 3.0 specification, running on the daphne reference server. Click the “via” link for my accompanying thread on Twitter, which includes a short screencast (also recorded on my phone) showing Glitch in action.

Via @simonw

Tags: glitch, projects, asgi

Language support on Glitch: a list

2019-04-23T16:28:35+00:00

Language support on Glitch: a list

This is really useful: it’s essentially “Glitch: the missing manual” for running languages other than JavaScript. The Glitch community forums are a gold mine of useful information like this.

Via @ann_arcana

Tags: glitch

Running Datasette on Glitch

2019-04-23T04:08:53+00:00

Update 28th May 2025: Sadly Glitch is shutting down user project hosting, so this tutorial is no longer relevant.

The worst part of any software project is setting up a development environment. It’s by far the biggest barrier for anyone trying to get started learning to code. I’ve been a developer for more than twenty years and I still feel the pain any time I want to do something new.

Glitch is the most promising attempt I’ve ever seen at tackling this problem. It provides an entirely browser-based development environment that allows you to edit code, see the results instantly and view and remix the source code of other people’s projects.

It’s developed into a really fun, super-creative community and a fantastic resource for people looking to get started in the ever-evolving world of software development.

This evening I decided to get Datasette running on it. I’m really impressed with how well it works, and I think Glitch provides an excellent environment for experimenting with Datasette and related tools.

TLDR version: visit https://glitch.com/edit/#!/remix/datasette-csvs right now, drag-and-drop in a CSV file and watch it get served by Datasette on Glitch just a few seconds later.

Running Python on Glitch

The Glitch documentation is all about Node.js and JavaScript, but they actually have very solid Python support as well.

Every Glitch project runs in a container that includes Python 2.7.12 and Python 3.5.2, and you can use pip install --user or pip3 install --user to install Python dependencies.

The key to running non-JavaScript projects on Glitch is the glitch.json file format. You can use this to specify an install script, which sets up your container, and a start script, which starts your application running. Glitch will route HTTP traffic to port 3000, so your application server needs to listen on that port.

This means the most basic Glitch project to run Datasette looks like this:

https://datasette-basic.glitch.me/ (view source)

It contains a single glitch.json file:

{
    "install": "pip3 install --user datasette",
    "start": "datasette -p 3000"
}

This installs Datasette using pip3, then runs it on port 3000.

Since there’s no actual data to serve, this is a pretty boring demo. The most interesting page is this one, which shows the installed versions of the software:

https://datasette-basic.glitch.me/-/versions

Something more interesting: datasette-csvs

Let’s build one with some actual data.

My csvs-to-sqlite tool converts CSV files into a SQLite database. Since it’s also written in Python we can run it against CSV files as part of the Glitch install script.

Glitch provides a special directory called .data/ which can be used as a persistent file storage space that won’t be cleared in between restarts. The following "install" script installs datasette and csvs-to-sqlite, then runs the latter to create a SQLite database from all available CSV files:

{
    "install":  "pip3 install --user datasette csvs-to-sqlite && csvs-to-sqlite *.csv .data/csv-data.db",
    "start": "datasette .data/csv-data.db -p 3000"
}

Now we can simply drag and drop CSV files into the root of the Glitch project and they will be automatically converted into a SQLite database and served using Datasette!

We need a couple of extra details. Firstly, we want Datasette to automatically re-build the database file any time a new CSV file is added or an existing CSV file is changed. We can do that by adding a "watch" block to glitch.json:

"watch": {
    "install": {
        "include": [
            "\\.csv$"
        ]
    }
}

This ensures that our "install" script will run again any time a CSV file changes.

Let’s tone down the rate at which the scripts execute, by using throttle to set the polling interval to once a second:

"throttle": 1000

The above almost worked, but I started seeing errors if I changed the number of columns in a CSV file, since doing so clashed with the schema that had already been created in the database.

My solution was to add code to the install script that would delete the SQLite database file before attempting to recreate it - using the rm ... || true idiom to prevent Glitch from failing the installation if the file it attempted to remove did not already exist.

My final glitch.json file looks like this:

{
  "install": "pip3 install --user datasette csvs-to-sqlite && rm .data/csv-data.db || true && csvs-to-sqlite *.csv .data/csv-data.db",
  "start": "datasette .data/csv-data.db -p 3000 -m metadata.json",
  "watch": {
    "install": {
      "include": [
        "\\.csv$"
      ]
    },
    "restart": {
      "include": [
        "^metadata.json$"
      ]
    },
    "throttle": 1000
  }
}

I also set it up to use Datasette’s metadata.json format, and automatically restart the server any time the contents of that file changes.

https://datasette-csvs.glitch.me/ (view source) shows the results, running against a simple example.csv file I created.

Remixing!

Here’s where things get really fun: Glitch projects support “remixing”, whereby anyone can click a link to create their own editable copy of a project.

Remixing works even if you aren’t logged in to Glitch! Anonymous projects expire after five days, so be sure to sign in with GitHub or Facebook if you want to keep yours around.

Try it out now: Visit https://glitch.com/edit/#!/remix/datasette-csvs to create your own remix of my project. Then drag a new CSV file directly into the editor and within a few seconds Datasette on Glitch will be up and running against a converted copy of your file!

Limitations

The Glitch help center article What technical restrictions are in place? describes their limits. Most importantly, projects are limited to 4,000 requests an hour - and there’s currently no way to increase that limit. They also limit projects to 200MB of disk space - easily enough to get started exploring some interesting CSV files with Datasette.

Next steps

I’m delighted at how easy this was to setup, and how much power the ability to remix these Datasette demos provides. I’m tempted to start creating remixable Glitch demos that illustrate other aspects of Datasette’s functionality such as plugins or full-text search.

Glitch is an exceptionally cool piece of software. I look forward to seeing their Python support continue to evolve.

Tags: glitch, hosting, projects, datasette

Quoting Glitch

2010-02-10T11:40:44+00:00

Glitch is built in an entirely new and different way for a game. The back end (java at the lowest level, with game logic scripted in Javascript) is designed for maximum flexibility and ease of deployment. That means we'll be able to push new content — new items, new places, new characters — on a daily basis. It also means that we'll have lots of APIs with which the game can be expanded and extended.

— Glitch

Tags: glitch, java, javascript, rhino

glitch zen

2010-02-10T11:36:14+00:00

glitch zen

Glitch is the upcoming online game from Tiny Speck, many of whom are ex Flickr and indeed ex Game Never Ending before that. Glitch Zen is the first fan site.

Tags: flickr, glitch, glitchzen, gne, tinyspeck