Open-source project
up-for-grabs/up-for-grabs.net avatar
up-for-grabs/up-for-grabs.net

up-for-grabs.net: two site stacks in one repository, and the new one builds into the old one's output directory

This is a list of projects which have curated tasks specifically for new contributors. These issues are a great way to get started with a project, or to help share the load of working on open source projects. Jump in!

6,036 stars2,521 forksJavaScriptNOASSERTION

At a glance

What is it?
A directory of open source projects that have curated tasks for newcomers. The repository carries a Jekyll site and an Astro plus Vue rewrite at the same time, with separate lint configs and the beta build landing inside the Jekyll output as a subdirectory.
Who is it for?
Use this site if you want an issue you can realistically finish as your first contribution, because the entire premise is that projects have already curated tasks for newcomers rather than leaving you to triage an unlabelled backlog. Contribute a listing by following docs/list-a-project.md and opening a pull request, since the catalogue is source content in the repository rather than a database you submit to.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • up-for-grabs/up-for-grabs.net6,036 ★ · +17
Star history
Repository2026-09-232026-11-15
up-for-grabs/up-for-grabs.net6k6k

17 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Two site stacks run side by side, and the beta build lands inside the legacy output

The most consequential thing in this repository is not visible from the README's front page, and it is the directory listing. There is a Jekyll site and there is an Astro rewrite, and both are present at once.

The Jekyll side is unmistakable: _config.yml, _data/, _includes/ and _layouts/ are the four directories Jekyll is built around, and they are accompanied by a Gemfile, a Gemfile.lock, a .ruby-version and a .bundle/ directory. That is a complete Ruby site as it stood in the Jekyll era.

The Astro side is equally unmistakable: astro.config.mjs at the root, a src/ directory, and its own configuration files in eslint-new.config.mjs and tsconfig.json and vitest.config.ts.

What makes the two coexist rather than merely both existing is the build output. The README's command table says npm run build builds your production site to ./_site/beta/. So the Astro build does not replace the Jekyll output directory; it writes into a beta subdirectory inside it. Whatever Jekyll produces, the new site lands alongside it under a path segment, which is why the rewrite can be developed and previewed without breaking the live site.

The default branch is gh-pages, which is the publishing arrangement that makes this work. A branch named gh-pages is the one GitHub Pages serves, and the README describes this repository as the source content for the website.

There is a CNAME file at the root as well, which is the custom domain configuration for GitHub Pages, and the project is at up-for-grabs.net rather than a github.io subdomain.

The beta stack is Astro with Vue, and it has two runtime dependencies

The command table in the README is the interface to the new stack, and it is short. You need a recent version of Node.js, then npm install installs dependencies, npm run dev starts a local dev server at localhost:4321, npm run build produces the production site, npm run preview previews the build locally before deploying, and npm run astro passes through to the Astro CLI for things like astro add and astro check, with npm run astro -- --help for the help text.

So this is Astro, and it is Astro with Vue rather than with a different framework. The dev dependencies say so explicitly: @astrojs/vue alongside @astrojs/check, and the new lint target globs src/**/*.astro and src/**/*.vue together, which is only meaningful if both file types are present in the new source tree.

The runtime dependency list is where it gets notable. There are exactly two entries:

json
  "dependencies": {
    "@tanstack/vue-query": "^5.104.5",
    "amdefine": ">=0.1.0"
  },

A data-fetching library for Vue and a module definition shim. Nothing else. Astro itself, the Vue integration and the compiler toolchain all live in devDependencies, which means the production dependency surface of the built site is those two packages.

The amdefine entry is the odd one and worth understanding rather than dismissing. It is a loader shim for AMD-style module definitions,. It is pinned only as >=0.1.0, which is the loosest constraint in the whole manifest.

The package manifest also states the toolchain floor, and it is a high one:

text
    "dev": "astro dev",
    "build": "astro build",
    "preview": "astro preview",
    "astro": "astro"
  },
  "engines": {
    "node": ">=24",
    "npm": ">=11"
  },

Node 24 or newer and npm 11 or newer. That is an engines constraint in package.json.

Node 24 and a pinned Ruby are both required, because both stacks are still real

The repository carries two toolchain pins at the root, .node-version and .ruby-version. That is the clearest single indication that neither stack is dead. A migration removes the old side, and this repository has not removed the Ruby one.

The practical consequence is that setting up a development environment means satisfying both, or at least understanding which one your change needs. If you are only touching the Astro rewrite, Node 24 with npm 11 is the whole requirement. If you touch anything Jekyll, _config.yml, the _data/ content or the _includes/ and _layouts/ templates, you also need the Ruby that .ruby-version names, with Bundler resolving Gemfile.lock.

The README is explicit that the setup instructions are not inline. To get involved you are pointed at .github/CONTRIBUTING.md, which is said to contain instructions about getting your environment set up, guidance for testing locally, and the commands to run to verify changes. So the authoritative setup instructions live in that file rather than on the front page, which is a normal arrangement and worth finding before you start rather than after.

Two development environment details are worth noticing because they are alternatives to installing things locally. There is a Dockerfile and a docker-compose.yml, so the Ruby side can be run in a container rather than installed. And there is a .devcontainer.json, so a development container can be provisioned automatically. Both exist, which suggests the project expects contributors to arrive with different setups and has decided to support both routes.

The test tooling differs between the stacks too, which is a second reason the toolchain question is not academic. The new side runs vitest, with npm run test mapped to vitest run, plus test:watch and test:coverage variants. The tests/ directory holds JavaScript tests that the old lint target covers (tests/**/*.js); no Ruby test runner is named in source.

The legacy side also has a directory called javascripts/ with main.js in it, and the old lint target covers javascripts/*.js and tests/**/*.js, so the original site had its own client-side JavaScript before the rewrite.

Two linters with separate configs, because there are two sets of files

The package manifest contains five eslint-related scripts, and they split cleanly into two groups that mirror the two stacks.

The old group operates on the old files. lint runs eslint against javascripts/*.js and tests/**/*.js, and lint-fix runs the same with --fix. There is also eslint-check, which is a different thing entirely: it pipes the printed eslint config through eslint-config-prettier-check, which verifies that the eslint configuration and the prettier configuration agree rather than reporting a code problem.

The new group operates on the new files, and it does so through a separate config file. lint-new runs eslint with -c eslint-new.config.mjs against src/**/*.astro, src/**/*.vue, *.mjs and src/**/*.ts. lint-new-fix is the same with --fix.

So there are two eslint configuration files at the root, eslint.config.mjs and eslint-new.config.mjs, and they are not interchangeable. That is the direct consequence of running two frameworks in one repository: a rule that makes sense for plain JavaScript in javascripts/ will not necessarily make sense for Astro components or Vue single-file components in src/.

Formatting is handled separately again, by prettier rather than eslint, with prettier running as --check. and prettier-fix as --write. across the whole repository. Note the scope difference: prettier covers everything with a single config, .prettierrc.json plus a .prettierignore, while eslint is scoped per stack. That is a reasonable division, and it also means a change to formatting conventions touches both stacks at once even though linting does not.

Type checking has its own entry point too, with check mapped to tsc. So the full local verification set is typecheck, two linters, prettier and vitest, and the commands to run them are in the contributing file rather than on the front page.

Adding a project is a pull request against documentation, not a form submission

The mechanism for getting a project listed is the simplest thing about this repository, and it is a pull request. The README says that if you know about or maintain a project that should be listed on Up for Grabs, you should follow the instructions to open a pull request, and the instructions live in docs/list-a-project.md.

So the catalogue is source content in a repository. The docs/ directory holds the two documents the README points at: list-a-project.md for adding an entry and how-it-works.md as an overview of the various parts of the project.

That structure has a consequence worth naming. Because the list is a pull request against a repository, adding a project is subject to the same review as a code change, which means a maintainer can reject a listing. The value of the site for a newcomer depends entirely on the tasks in it being real and still open, and a review step is the mechanism that enforces that. A directory that anyone could self-add to would fill with stale issues within weeks and stop being worth reading.

The rest of the repository's structure supports the same idea. There are icons/, images/ and stylesheets/ directories for the site's assets, favicon.ico and robots.txt for the usual web files, browserconfig.xml for Windows tile configuration, and a scripts/ directory for build tooling. A Netlify deploy badge points at a test bench site, which suggests the site is previewed on a hosting platform before changes reach the live branch.

The contributor record is handled with the all-contributors specification, with a .all-contributorsrc at the root and an emoji key linked from the README. The visible contributor table distinguishes three roles by emoji rather than lumping everyone together: a pen-like icon for content contributions, a laptop icon for code, and a book icon for documentation. Contributors of any kind are welcomed explicitly, which for a site whose entire purpose is lowering the barrier to first contributions is a fitting thing to state.

What the site cannot do for you, and what the repository does not tell you

Four limits, each of which follows from what the project actually is.

It cannot tell you whether a task is still open. The site is a curated list, and curation means a human decided at some point that these issues were approachable. Whether an issue is still open, still unassigned or still described the same way is a question about the upstream repository, and a stale entry is exactly the failure mode that review cannot prevent.

It does not rank difficulty. There is no difficulty scoring in the description and no way to compare two tasks on the same axis. The value is that the tasks were chosen for newcomers, not that they are ordered or quantified.

It is a website, not a service. There is no API described, no account system, and nothing in the repository suggesting either. Everything the site knows is in the repository, which is why the repository is the thing to read if you want to understand what it is doing.

And the repository does not record a release history. There are no GitHub releases, and the default branch is gh-pages, which means there is no tag to pin and no changelog to consult for the site itself. The activity signal available is the commit history on the default branch and the last push date.

On the licence, there is a mismatch worth resolving before you contribute code rather than a listing. The manifest records the project as MIT, and there is a LICENSE file at the root, but the recorded licence field for the repository is NOASSERTION. Automated tooling reading the metadata will learn nothing. If you are contributing code, read the LICENSE file; if you are listing a project, the question does not arise, and the contribution is documentation.

The practical sequence for a first contribution, in order: find a task on the site, read the upstream project's own contributing guide rather than starting from the issue, and expect the pull request to be reviewed as carefully as any other. The site lowers the cost of finding work; it does not lower the standard for the work itself.

Editorial conclusion

Use this site if you want an issue you can realistically finish as your first contribution, because the entire premise is that projects have already curated tasks for newcomers rather than leaving you to triage an unlabelled backlog. Contribute a listing by following docs/list-a-project.md and opening a pull request, since the catalogue is source content in the repository rather than a database you submit to. If you want to work on the site itself, read docs/how-it-works.md first, because the repository runs two stacks simultaneously and the Astro rewrite builds into ./_site/beta/ rather than replacing the Jekyll output. And be aware of the toolchain floor before you start: Node 24 or newer with npm 11, alongside a pinned Ruby for the legacy side.

Frequently asked questions

What is up-for-grabs.net and how do I get a project listed?

It is a list of open source projects that have curated tasks specifically for new contributors, intended both as a way to get started with a project and as a way to share the load of working on open source. Listing a project is done by opening a pull request against this repository and following docs/list-a-project.md, so the catalogue is source content rather than a separate submission system and every addition goes through review.

How do I build and preview the site locally?

You need Node.js 24 or newer and npm 11 or newer, then npm install, and npm run dev starts a local server at localhost:4321. For a production build, npm run build outputs to ./_site/beta/, and npm run preview serves that build locally before you deploy. npm run astro passes through to the Astro CLI for commands like astro add and astro check. Full setup instructions, local testing guidance and the verification commands are in .github/CONTRIBUTING.md.

Why are there two linters and two test setups in this repository?

Because the repository runs two site stacks at once. The legacy side has javascripts/ and tests/**/*.js linted by the default eslint config, while the Astro rewrite under src/ is linted by a separate eslint-new.config.mjs covering .astro, .vue, .mjs and .ts files and tested with vitest. Formatting is not split: prettier runs once across the whole repository with a single config.

What licence is up-for-grabs.net under?

The package manifest records the project as MIT and there is a LICENSE file at the repository root, but the recorded licence field for the repository itself is NOASSERTION, which is the marker used when a licence cannot be classified automatically. If you are contributing code rather than a project listing, read the LICENSE file directly, since tooling reading the repository metadata will learn nothing.

Official sources

  1. Issues
  2. Project website
  3. README
  4. up-for-grabs/up-for-grabs.net on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/up-for-grabs-up-for-grabs-net.svg)](https://hysenlabs.com/projects/up-for-grabs-up-for-grabs-net)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/up-for-grabs-up-for-grabs-net.svg)](https://hysenlabs.com/projects/up-for-grabs-up-for-grabs-net)

Was this useful?