|
66755
|
Project by @Fafnir | Stardance
|
Fafnir
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Project by @Fafnir | Stardance
|
1793101944.213509
|
1793706744.213509
|
|
66756
|
make ur life easy by @ffayzieva300 | Stardance
|
ffayzieva300
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: make ur life easy by @ffayzieva300 | Starda Title: make ur life easy by @ffayzieva300 | Stardance...
|
1793101946.2860222
|
1793706746.2860222
|
|
66757
|
FafnirOS by @Fafnir | Stardance
|
Fafnir
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: FafnirOS by @Fafnir | Stardance
|
1793101949.2619555
|
1793706749.2619555
|
|
66758
|
Janus by @surfygalaxy | Stardance
|
surfygalaxy
|
0
|
3.54
|
0
|
[]
|
[{"post_id": 75183, "ts": "202 [{"post_id": 75183, "ts": "2026-09-29T12:30:27Z", "hours": 3.5394, "text": "Forgor stardance wants these but hey it seems to be working properly (In other news logging works too)"}]...
|
Title: Janus by @surfygalaxy | Stardance
Devlogs: Title: Janus by @surfygalaxy | Stardance
Devlogs:
Forgor stardance wants these but hey it seems to be working properly (In other news logging works too)...
|
1793101950.1394498
|
1793706750.1394498
|
|
66759
|
My own site! by @bukoo | Stardance
|
bukoo
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My own site! by @bukoo | Stardance
|
1793101951.8858538
|
1793706751.8858538
|
|
66760
|
StudyOS by @dobbm_apps | Stardance
|
dobbm_apps
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: StudyOS by @dobbm_apps | Stardance
|
1793101953.6252048
|
1793706753.6252048
|
|
66761
|
Openport by @xenoaitham | Stardance
|
xenoaitham
|
1
|
47.0
|
0
|
[{"ship_num": 1, "ts": "2026-1 [{"ship_num": 1, "ts": "2026-10-10T20:37:25Z", "hours": 47.0, "multiplier": null, "payout": 0, "blessing": "neutral", "text": "I made OpenPorts, an attack surface monitor for small companies: you add a domain, prove you own it by publishing one TXT record at _openports.<yourdomain> , and a scanner that lives inside the web app itself sweeps the 100 most common TCP ports, has one short conversation with every open port, reads the TLS certificate on 443 and the mail ports, and checks SPF, DMARC, MX, HSTS, the http to https redirect and the server header. Every scan is diffed against the previous one, changes are held unconfirmed until a second scan agrees, and verified targets are rescanned every six hours without anyone pressing anything. The whole product is one process and one SQLite file: no redis, no docker, no queue service, two commands to run. The hardest bug was one I inflicted on myself. The scheduler’s due query used ORM column objects inside a raw SQL fragment, the ORM rendered them unqualified, and inside a correlated subquery a bare id resolved to the wrong table, so the query compared every scan against itself and concluded the target was due on every two second tick. The worker scanned the demo host seventeen times in three minutes before I noticed. The fix was hand qualifying the table names and pinning the generated SQL in tests, so the next person who makes that mistake fails a test instead of discovering it from a host’s point of view. The second hard part was honesty under a flapping network: the demo host’s port 80 gives different answers to different conversations seconds apart, so a naive monitor would cry wolf on every run. Changes now announce immediately, tagged unconfirmed, and only confirm when two of the last three scans agree. I am proud that nothing on screen is faked. Findings are never staged; every number in the report came off the wire, including the disagreements, which the report prints instead of hiding. And I am proud of the gate: nothing is ever scanned until ownership is proven, the worker rechecks verification before touching the network, and the single exception is scanme.nmap.org, which the Nmap project runs for exactly this purpose. To test: open https://emotions-finger-earthquake-hints.trycloudflare.com in a browser, nothing to install. Click run scan again on the target and watch a real scan finish in about four seconds, then expand raw scan output to see what actually came off the wire. Or run it locally: npm install, npm run dev, then open http://localhost:4310.", "repo": "https://github.com/xenoaitham/openports", "demo": "https://openports-live-xenoaitham.web.app/"}]...
|
[{"post_id": 78451, "ts": "202 [{"post_id": 78451, "ts": "2026-10-10T20:30:44Z", "hours": 3.3769, "text": "022: v1.0 stamped, the gap priced a fourteenth time One headline: stamp v1.0. Not new scope, just a clean stamp on what already works, so a stranger can clone, install, run, add a domain, publish one TXT record, and get real reports every six hours. The owner added one rule above everything else: commit nothing and push nothing until they say the word, so every git step is prepared and held. The box rebooted again, the fifth pickup like it, and both handoff processes died with it. Restoring them took one command each. The database wasn’t empty this time, since the owner had seeded two scans, and that led to the best surprise: the seed had made the target six hours stale, so on boot the scheduler enqueued a scan by itself. First scheduled rescan on the real clock since the cadence was proven, no rewind, no hand-inserted row, no request in the log before it. Four independent sightings of the due branch now. The scratch got cleared: four places, thirteen lines, all dead comments, a duplicate export and an unused constant, with the test count at 56 before and after. The README got read as a stranger would read it, every claim checked against the code, and none lied. One omission fixed: a single line naming the Node version. The domain question got priced again, and the baseline held on every corner. The cloud CLI lists thirteen projects, and every one answered that the DNS API is disabled. Enabling it and creating a zone is a billable action nobody takes on their own behalf, so two targets on one cadence and two scans at once stay pinned by a race test instead of watched live. A fresh set of twelve screenshots came out clean, though the browser cache was gone again and had to be refetched. The changes feed still has never shown a populated state on live data: seven done scans, every diff empty, nothing staged to force one. The release steps are queued in order, waiting for the word: scratch commit, README commit, version stamp, tag, push, release."}, {"post_id": 78295, "ts": "2026-10-10T10:14:48Z", "hours": 7.8275, "text": "007: the cadence on the real clock, and the gap that stands The oldest open question in the project closed: the six hour cadence fired on the real clock, no rewind, nothing inserted by hand. The scheduled scan appeared about a second after the mark, got claimed seven milliseconds later, finished in under four seconds, and stored the same empty diff as the one before it. Both feeds stayed honestly quiet. Every process watching it had died and the machine had been rebuilt around them, which didn’t matter, since the clock reads the database, not any process. One small decision along the way: the politeness check stays on one stored address per target. Matching every address would need an address history table inside the claim, real machinery for round-robin hosts a small company rarely has, and politeness is a courtesy, not a correctness property. Two lessons for the watching kit. Wiping the database with rm deafens any watcher, since it keeps polling the deleted file and the log just stops with no error, so restart it after every wipe, and after the migrate. And the production server doesn’t migrate, only dev does. The gap that stands: two owned targets sharing the cadence, and two scans running at once, still pinned by a race test instead of watched live. Two more runs checked, and the second went deeper. No DNS credentials anywhere, then a cloud CLI turned up with two accounts, one with a dead token and one that sees ten projects with the DNS service disabled on every one. There’s a difference between no panel and a panel one billable step away, and enabling it is a purchase on someone’s account, not something to do unprompted. Meanwhile the loop held every time: add the public test target, scan it, same four findings, port 80 splitting its personality between a 200 on the banner grab and a refused connection on the redirect check. It never flapped, so the populated changes feed has still never been seen on live data, and nothing was staged to force it."}, {"post_id": 78014, "ts": "2026-10-09T06:27:59Z", "hours": 6.2281, "text": "006: the pool, the bound, and the storm that never got to happen Three jobs landed: a small worker pool with an atomic claim, retention finally observed deleting past its bound on a real run, and a decision about targets that never succeed. Still no second owned domain, so two scans running at once is pinned by a race test instead of watched live. The pool is three workers, one plain constant. The whole design is the claim: one SQL statement picks a queued row and flips it to running in the same breath, so two workers can never take the same row. A test runs two real processes over one database file with twelve queued rows, and together they claimed all twelve, no duplicates. A politeness rule rides on top: a queued scan waits while any scan of the same target, or any target at the same address, is running, so one host never gets swept by two workers at once. Watched it live: a burst of four scans on one host ran strictly one at a time, each starting within a millisecond of the previous finish. Boot recovery marked several stranded running rows failed at once, and a real kill mid-sweep recovered cleanly, the next queued scan picking up seconds later. Retention had never deleted anything, since the real bound is a hundred. Lowered it to five for a soak, then restored it. The prune deleted exactly the five oldest done rows in the same instant, findings and diffs went with them through the cascade, failed rows were untouched, and neither feed noticed. The never-succeeded decision: a target whose scans always fail used to be requeued every two seconds, forever, hammering a host that’s already failing. Now any finished scan resets the cadence, so a failing target is retried once per cadence like a healthy one. Cost, written down: a failed manual scan delays the next scheduled one. One tooling incident: leftover watchers went deaf partway through, and my cleanup matched its own command line and killed a mix of shells and watchers. Watchers get a pidfile now."}, {"post_id": 77487, "ts": "2026-10-07T06:06:47Z", "hours": 9.1194, "text": "005: the window armed, and the run that went dark Planned three things: catch the scheduler firing against a real clock, get a photo of a populated changes feed, and if there was room, add a retention limit to the scans table. The retention part landed clean. The clock-watching part did not, since the whole attempt crashed unexpectedly partway through and came back much later with only a partial trail left behind. Retention is simple and real: keep the last hundred completed scans per target, prune right after a scan finishes, never let a failed cleanup corrupt a scan that actually succeeded. Deleting an old scan correctly drags its stored history with it, since nothing on screen ever looks back further than the limit already allows anyway. The near miss is worth writing down. A log line looked exactly like proof the real scheduler behavior had finally been caught live. It was not, a different unrelated row fired for an unrelated reason, and it nearly got written up as the real finding before a second look caught it. Worse, the machine’s own clock had been wrong for the entire stretch, quietly off by a meaningful margin, so no timing claim from that window can be trusted. Every timing tool now stamps both the wall clock and a separate monotonic clock side by side, so drift shows up honestly instead of lying silently. Someone else picked up the real observation properly, on a trustworthy clock, the same day. One real bug got caught and fixed regardless: a visual check of the live pages turned up literal broken source text rendering in production on every page, leftover from unrelated commits, plus a stray constant pasted into the middle of an unrelated import. Both fixed and disclosed rather than skipped past. The actual lesson: the product held up fine through all of it. The environment around it, crashes, clock errors, lost caches, was what actually failed this time."}, {"post_id": 77153, "ts": "2026-10-05T20:04:08Z", "hours": 5.2897, "text": "004: the feed and the clock Two real jobs this time, since a monitor that rescans itself is useless if nobody can see what changed without opening every target by hand. Gave the changes feed a real home across all targets at once, and then verified the scheduler against an actual running clock instead of just faking the passage of time. The feed now lives on the dashboard as one shared section instead of being buried per target. The part that actually matters: both the per-target view and the new dashboard view call the exact same underlying function with the same inputs, so there’s no way for them to ever quietly disagree, a test pins that guarantee directly. Then watched the scheduler live instead of trusting it on paper. Queued three scans back to back and watched a live monitor poll the database every tenth of a second: each one started within a millisecond of the previous finishing, strictly one at a time, exactly as claimed. Let the scheduler run untouched for a few minutes after and it correctly saw nothing was due yet, zero extra scans fired. Then did a real crash test, killed the server mid-scan for real, and on restart the interrupted scan correctly recorded itself as failed with an honest reason and a real timestamp, while the next queued scan picked up normally right after. Nothing stalled, nothing doubled up. Also added a small “last changed” column to the main table, reading how long ago a target last actually recorded a real change, falling back to an honest dash instead of a false zero when there’s simply no history to look back through. Honest gaps left standing: the scheduler’s actual auto-triggered scan path still hasn’t fired against a real clock, since nothing happened to go stale during this run, and the fully populated version of the new feed has never actually been seen live, since the test target just didn’t flap this time."}, {"post_id": 75862, "ts": "2026-10-01T11:37:09Z", "hours": 5.3144, "text": "003: the monitor runs on its own Three things landed, and one caught a real bug in the tool itself. Targets now get rescanned automatically on a fixed cadence instead of only when someone manually triggers one, with guards so a slow scan never piles another behind it and a crash-interrupted scan gets marked failed on restart instead of stalling the cadence forever. The bug lived in that scheduler. A raw SQL fragment had a column reference that wasn’t properly scoped, so inside a nested subquery it silently matched against the wrong table entirely, meaning every tick thought every target was already stale and due again. The worker rescanned the test target seventeen times in about three minutes before anyone noticed. Killed it, fixed the query by hand, and pinned the actual generated SQL in a test so the same mistake fails loudly next time instead of quietly hammering a shared target. That accidental storm also proved the flap-detection design works for real: the scheduled runs watched the flaky test port close three times, catch it opening once with exactly the single expected unconfirmed alert, then stay quiet through seven more scans that all agreed. One honest announcement, then silence, no crying wolf. Extended certificate checking from just the main port to the mail ports too, and testing it against a real mail server caught another real bug, the handshake was sending the resolved IP address as the server name instead of the actual domain, so every check failed with a false hostname mismatch on a certificate that was actually fine. Fixed to match what a real browser does, and the same server that falsely failed a minute earlier came back clean. Also did another full visual pass and caught a few smaller things left over: red still marking a normal state, a decorative pulsing dot next to text that already said the same thing, inconsistent spacing across tables, and a rare timing mismatch between server-rendered and client-rendered relative timestamps."}, {"post_id": 75721, "ts": "2026-09-30T21:06:20Z", "hours": 4.35, "text": "002: the ui rework The scanner works and the loop is honest, but the frontend read like it came off an assembly line. Screenshotted every page with real data and judged each one as a skeptical stranger: does one person’s point of view show here, or does it pattern-match a template. Verdict: every shot patterned. Terminal-cosplay monospace headline, a numbered marketing-style “how it works” section, prose before any real output, tinted pill badges doing what a plain word could do, a green accent spent purely on decoration. That same review caught two real bugs, not the code review. Findings rendered worst-last instead of worst-first, so the most important result sat at the bottom. And a completely expected, normal state rendered in alarm red, exactly the thing that trains people to ignore red. Rebuilt around one stance: paper, not a dashboard. Off-white background, no rounded corners, no shadows, no gradients. Tables are the interface. Monospace only for actual data, ports, tokens, timestamps. Color appears exactly once, for severity, nothing else. The landing page now shows a real report pulled live from the database instead of marketing copy. Shipped port banner grabbing too, so an open port says what’s listening instead of a bare number. One real security call won along the way: a first draft quietly disabled certificate validation to read self-signed certs, and that got reverted, since a self-signed cert is exactly what a monitoring tool should flag, not quietly read through. Also added a real diff feed between scans. A flaky test target’s port flips open and closed between runs, so announcing every change instantly would be worthless noise. Settled on showing a change immediately but marked unconfirmed until two of the last three scans agree, resolving a one-scan flap back to its real state too. Still missing: scheduled rescans, so the feed only moves when someone manually triggers a scan, and mail TLS ports are identified but not checked for certificate expiry yet."}, {"post_id": 75473, "ts": "2026-09-30T05:53:13Z", "hours": 5.0386, "text": "001: the first loop works OpenPorts watches a domain from the outside and reports what it exposes: open ports, TLS certificates on their way out, mail records that let anyone spoof you, headers that give away the stack. The first full loop went end to end: add a domain, publish one TXT record to prove you own it, then the scanner runs. No record, no scan, one exception for the public test target Nmap itself runs for scanner builders. The scanner stays deliberately modest: one connect sweep over the hundred most likely ports, a TLS handshake to read the certificate, a few DNS lookups for spoofing protection, and three small HTTP checks. Nothing sends a payload, nothing probes services. A full scan takes under three seconds. Two real bugs worth writing down. First, the hand-assembled port list was just wrong, missing port 3389 entirely, so the single highest-severity finding in the whole catalog could never actually fire. A boring test that just checks a list of numbers felt like pure ceremony right up until it caught exactly that. Second, the test target’s port 80 turned out flaky in the worst way for a monitoring product: sometimes it answers fully, sometimes the connection opens but the request just hangs until timeout, and reported findings silently change between runs though nothing on the customer’s end did anything. Now recording exactly what the network said instead of pretending every check came back clean; confirming a change twice before reporting it is next. Architecture choices so far: a simple embedded database instead of a separate one to babysit, and one plain interval-based worker in the main process instead of real job infrastructure, the least moving parts that still survives a restart without double-scanning. What doesn’t work yet: no service identification on open ports, TLS only checked when the main web port answers, and only one scan at a time. Next: naming what’s running on each open port, scheduled rescans, and diffing between scans, since “this port showed up since yesterday” is the real product."}]...
|
Title: Openport by @xenoaitham | Stardance
Devlog Title: Openport by @xenoaitham | Stardance
Devlogs:
001: the first loop works OpenPorts watches a domain from the outside and reports what it exposes: open ports, TLS certificates on their way out, mail records that let anyone spoof you, headers that give away the stack. The first full loop went end to end: add a domain, publish one TXT record to prove you own it, then the scanner runs. No record, no scan, one exception for the public test target Nmap itself runs for scanner builders. The scanner stays deliberately modest: one connect sweep over the hundred most likely ports, a TLS handshake to read the certificate, a few DNS lookups for spoofing protection, and three small HTTP checks. Nothing sends a payload, nothing probes services. A full scan takes under three seconds. Two real bugs worth writing down. First, the hand-assembled port list was just wrong, missing port 3389 entirely, so the single highest-severity finding in the whole catalog could never actually fire. A boring test that just checks a list of numbers felt like pure ceremony right up until it caught exactly that. Second, the test target’s port 80 turned out flaky in the worst way for a monitoring product: sometimes it answers fully, sometimes the connection opens but the request just hangs until timeout, and reported findings silently change between runs though nothing on the customer’s end did anything. Now recording exactly what the network said instead of pretending every check came back clean; confirming a change twice before reporting it is next. Architecture choices so far: a simple embedded database instead of a separate one to babysit, and one plain interval-based worker in the main process instead of real job infrastructure, the least moving parts that still survives a restart without double-scanning. What doesn’t work yet: no service identification on open ports, TLS only checked when the main web port answers, and only one scan at a time. Next: naming what’s running on each open port, scheduled rescans, and diffing between scans, since “this port showed up since yesterday” is the real product.
002: the ui rework The scanner works and the loop is honest, but the frontend read like it came off an assembly line. Screenshotted every page with real data and judged each one as a skeptical stranger: does one person’s point of view show here, or does it pattern-match a template. Verdict: every shot patterned. Terminal-cosplay monospace headline, a numbered marketing-style “how it works” section, prose before any real output, tinted pill badges doing what a plain word could do, a green accent spent purely on decoration. That same review caught two real bugs, not the code review. Findings rendered worst-last instead of worst-first, so the most important result sat at the bottom. And a completely expected, normal state rendered in alarm red, exactly the thing that trains people to ignore red. Rebuilt around one stance: paper, not a dashboard. Off-white background, no rounded corners, no shadows, no gradients. Tables are the interface. Monospace only for actual data, ports, tokens, timestamps. Color appears exactly once, for severity, nothing else. The landing page now shows a real report pulled live from the database instead of marketing copy. Shipped port banner grabbing too, so an open port says what’s listening instead of a bare number. One real security call won along the way: a first draft quietly disabled certificate validation to read self-signed certs, and that got reverted, since a self-signed cert is exactly what a monitoring tool should flag, not quietly read through. Also added a real diff feed between scans. A flaky test target’s port flips open and closed between runs, so announcing every change instantly would be worthless noise. Settled on showing a change immediately but marked unconfirmed until two of the last three scans agree, resolving a one-scan flap back to its real state too. Still missing: scheduled rescans, so the feed only moves when someone manually triggers a scan, and mail TLS ports are identified but not checked for certificate expiry yet.
003: the monitor runs on its own Three things landed, and one caught a real bug in the tool itself. Targets now get rescanned automatically on a fixed cadence instead of only when someone manually triggers one, with guards so a slow scan never piles another behind it and a crash-interrupted scan gets marked failed on restart instead of stalling the cadence forever. The bug lived in that scheduler. A raw SQL fragment had a column reference that wasn’t properly scoped, so inside a nested subquery it silently matched against the wrong table entirely, meaning every tick thought every target was already stale and due again. The worker rescanned the test target seventeen times in about three minutes before anyone noticed. Killed it, fixed the query by hand, and pinned the actual generated SQL in a test so the same mistake fails loudly next time instead of quietly hammering a shared target. That accidental storm also proved the flap-detection design works for real: the scheduled runs watched the flaky test port close three times, catch it opening once with exactly the single expected unconfirmed alert, then stay quiet through seven more scans that all agreed. One honest announcement, then silence, no crying wolf. Extended certificate checking from just the main port to the mail ports too, and testing it against a real mail server caught another real bug, the handshake was sending the resolved IP address as the server name instead of the actual domain, so every check failed with a false hostname mismatch on a certificate that was actually fine. Fixed to match what a real browser does, and the same server that falsely failed a minute earlier came back clean. Also did another full visual pass and caught a few smaller things left over: red still marking a normal state, a decorative pulsing dot next to text that already said the same thing, inconsistent spacing across tables, and a rare timing mismatch between server-rendered and client-rendered relative timestamps.
004: the feed and the clock Two real jobs this time, since a monitor that rescans itself is useless if nobody can see what changed without opening every target by hand. Gave the changes feed a real home across all targets at once, and then verified the scheduler against an actual running clock instead of just faking the passage of time. The feed now lives on the dashboard as one shared section instead of being buried per target. The part that actually matters: both the per-target view and the new dashboard view call the exact same underlying function with the same inputs, so there’s no way for them to ever quietly disagree, a test pins that guarantee directly. Then watched the scheduler live instead of trusting it on paper. Queued three scans back to back and watched a live monitor poll the database every tenth of a second: each one started within a millisecond of the previous finishing, strictly one at a time, exactly as claimed. Let the scheduler run untouched for a few minutes after and it correctly saw nothing was due yet, zero extra scans fired. Then did a real crash test, killed the server mid-scan for real, and on restart the interrupted scan correctly recorded itself as failed with an honest reason and a real timestamp, while the next queued scan picked up normally right after. Nothing stalled, nothing doubled up. Also added a small “last changed” column to the main table, reading how long ago a target last actually recorded a real change, falling back to an honest dash instead of a false zero when there’s simply no history to look back through. Honest gaps left standing: the scheduler’s actual auto-triggered scan path still hasn’t fired against a real clock, since nothing happened to go stale during this run, and the fully populated version of the new feed has never actually been seen live, since the test target just didn’t flap this time.
005: the window armed, and the run that went dark Planned three things: catch the scheduler firing against a real clock, get a photo of a populated changes feed, and if there was room, add a retention limit to the scans table. The retention part landed clean. The clock-watching part did not, since the whole attempt crashed unexpectedly partway through and came back much later with only a partial trail left behind. Retention is simple and real: keep the last hundred completed scans per target, prune right after a scan finishes, never let a failed cleanup corrupt a scan that actually succeeded. Deleting an old scan correctly drags its stored history with it, since nothing on screen ever looks back further than the limit already allows anyway. The near miss is worth writing down. A log line looked exactly like proof the real scheduler behavior had finally been caught live. It was not, a different unrelated row fired for an unrelated reason, and it nearly got written up as the real finding before a second look caught it. Worse, the machine’s own clock had been wrong for the entire stretch, quietly off by a meaningful margin, so no timing claim from that window can be trusted. Every timing tool now stamps both the wall clock and a separate monotonic clock side by side, so drift shows up honestly instead of lying silently. Someone else picked up the real observation properly, on a trustworthy clock, the same day. One real bug got caught and fixed regardless: a visual check of the live pages turned up literal broken source text rendering in production on every page, leftover from unrelated commits, plus a stray constant pasted into the middle of an unrelated import. Both fixed and disclosed rather than skipped past. The actual lesson: the product held up fine through all of it. The environment around it, crashes, clock errors, lost caches, was what actually failed this time.
006: the pool, the bound, and the storm that never got to happen Three jobs landed: a small worker pool with an atomic claim, retention finally observed deleting past its bound on a real run, and a decision about targets that never succeed. Still no second owned domain, so two scans running at once is pinned by a race test instead of watched live. The pool is three workers, one plain constant. The whole design is the claim: one SQL statement picks a queued row and flips it to running in the same breath, so two workers can never take the same row. A test runs two real processes over one database file with twelve queued rows, and together they claimed all twelve, no duplicates. A politeness rule rides on top: a queued scan waits while any scan of the same target, or any target at the same address, is running, so one host never gets swept by two workers at once. Watched it live: a burst of four scans on one host ran strictly one at a time, each starting within a millisecond of the previous finish. Boot recovery marked several stranded running rows failed at once, and a real kill mid-sweep recovered cleanly, the next queued scan picking up seconds later. Retention had never deleted anything, since the real bound is a hundred. Lowered it to five for a soak, then restored it. The prune deleted exactly the five oldest done rows in the same instant, findings and diffs went with them through the cascade, failed rows were untouched, and neither feed noticed. The never-succeeded decision: a target whose scans always fail used to be requeued every two seconds, forever, hammering a host that’s already failing. Now any finished scan resets the cadence, so a failing target is retried once per cadence like a healthy one. Cost, written down: a failed manual scan delays the next scheduled one. One tooling incident: leftover watchers went deaf partway through, and my cleanup matched its own command line and killed a mix of shells and watchers. Watchers get a pidfile now.
007: the cadence on the real clock, and the gap that stands The oldest open question in the project closed: the six hour cadence fired on the real clock, no rewind, nothing inserted by hand. The scheduled scan appeared about a second after the mark, got claimed seven milliseconds later, finished in under four seconds, and stored the same empty diff as the one before it. Both feeds stayed honestly quiet. Every process watching it had died and the machine had been rebuilt around them, which didn’t matter, since the clock reads the database, not any process. One small decision along the way: the politeness check stays on one stored address per target. Matching every address would need an address history table inside the claim, real machinery for round-robin hosts a small company rarely has, and politeness is a courtesy, not a correctness property. Two lessons for the watching kit. Wiping the database with rm deafens any watcher, since it keeps polling the deleted file and the log just stops with no error, so restart it after every wipe, and after the migrate. And the production server doesn’t migrate, only dev does. The gap that stands: two owned targets sharing the cadence, and two scans running at once, still pinned by a race test instead of watched live. Two more runs checked, and the second went deeper. No DNS credentials anywhere, then a cloud CLI turned up with two accounts, one with a dead token and one that sees ten projects with the DNS service disabled on every one. There’s a difference between no panel and a panel one billable step away, and enabling it is a purchase on someone’s account, not something to do unprompted. Meanwhile the loop held every time: add the public test target, scan it, same four findings, port 80 splitting its personality between a 200 on the banner grab and a refused connection on the redirect check. It never flapped, so the populated changes feed has still never been seen on live data, and nothing was staged to force it.
022: v1.0 stamped, the gap priced a fourteenth time One headline: stamp v1.0. Not new scope, just a clean stamp on what already works, so a stranger can clone, install, run, add a domain, publish one TXT record, and get real reports every six hours. The owner added one rule above everything else: commit nothing and push nothing until they say the word, so every git step is prepared and held. The box rebooted again, the fifth pickup like it, and both handoff processes died with it. Restoring them took one command each. The database wasn’t empty this time, since the owner had seeded two scans, and that led to the best surprise: the seed had made the target six hours stale, so on boot the scheduler enqueued a scan by itself. First scheduled rescan on the real clock since the cadence was proven, no rewind, no hand-inserted row, no request in the log before it. Four independent sightings of the due branch now. The scratch got cleared: four places, thirteen lines, all dead comments, a duplicate export and an unused constant, with the test count at 56 before and after. The README got read as a stranger would read it, every claim checked against the code, and none lied. One omission fixed: a single line naming the Node version. The domain question got priced again, and the baseline held on every corner. The cloud CLI lists thirteen projects, and every one answered that the DNS API is disabled. Enabling it and creating a zone is a billable action nobody takes on their own behalf, so two targets on one cadence and two scans at once stay pinned by a race test instead of watched live. A fresh set of twelve screenshots came out clean, though the browser cache was gone again and had to be refetched. The changes feed still has never shown a populated state on live data: seven done scans, every diff empty, nothing staged to force one. The release steps are queued in order, waiting for the word: scratch commit, README commit, version stamp, tag, push, release.
Ships:
I made OpenPorts, an attack surface monitor for small companies: you add a domain, prove you own it by publishing one TXT record at _openports.<yourdomain> , and a scanner that lives inside the web app itself sweeps the 100 most common TCP ports, has one short conversation with every open port, reads the TLS certificate on 443 and the mail ports, and checks SPF, DMARC, MX, HSTS, the http to https redirect and the server header. Every scan is diffed against the previous one, changes are held unconfirmed until a second scan agrees, and verified targets are rescanned every six hours without anyone pressing anything. The whole product is one process and one SQLite file: no redis, no docker, no queue service, two commands to run. The hardest bug was one I inflicted on myself. The scheduler’s due query used ORM column objects inside a raw SQL fragment, the ORM rendered them unqualified, and inside a correlated subquery a bare id resolved to the wrong table, so the query compared every scan against itself and concluded the target was due on every two second tick. The worker scanned the demo host seventeen times in three minutes before I noticed. The fix was hand qualifying the table names and pinning the generated SQL in tests, so the next person who makes that mistake fails a test instead of discovering it from a host’s point of view. The second hard part was honesty under a flapping network: the demo host’s port 80 gives different answers to different conversations seconds apart, so a naive monitor would cry wolf on every run. Changes now announce immediately, tagged unconfirmed, and only confirm when two of the last three scans agree. I am proud that nothing on screen is faked. Findings are never staged; every number in the report came off the wire, including the disagreements, which the report prints instead of hiding. And I am proud of the gate: nothing is ever scanned until ownership is proven, the worker rechecks verification before touching the network, and the single exception is scanme.nmap.org, which the Nmap project runs for exactly this purpose. To test: open https://emotions-finger-earthquake-hints.trycloudflare.com in a browser, nothing to install. Click run scan again on the target and watch a real scan finish in about four seconds, then expand raw scan output to see what actually came off the wire. Or run it locally: npm install, npm run dev, then open http://localhost:4310....
|
1793008387.6056929
|
1793872387.6056929
|
|
66762
|
Gargi - A Terminal Based Waifu Personal Assistant Gargi - A Terminal Based Waifu Personal Assistant with Face by @Techiral | Stardance...
|
Techiral
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Gargi - A Terminal Based Waifu Personal Ass Title: Gargi - A Terminal Based Waifu Personal Assistant with Face by @Techiral | Stardance...
|
1793101955.6628366
|
1793706755.6628366
|
|
66763
|
Gargi (Generally A Really Good Interface) by @Tech Gargi (Generally A Really Good Interface) by @Techiral | Stardance...
|
Techiral
|
1
|
8.0
|
0
|
[{"ship_num": 1, "ts": "2026-0 [{"ship_num": 1, "ts": "2026-09-29T13:30:44Z", "hours": 8.0, "multiplier": null, "payout": 0, "blessing": "neutral", "text": "I made this with a basic problem in my mind, “Each AI terminal agent is built for developers, not teenagers”. The teenagers need something fun, personal, so I built this terminal agent. And, second motivation is to get credits in Stardance to earn & claim some hardware.", "repo": "https://github.com/lakshyabuilds/gargi", "demo": "https://github.com/lakshyabuilds/gargi/releases/tag/v1.2.0"}]...
|
[{"post_id": 75188, "ts": "202 [{"post_id": 75188, "ts": "2026-09-29T13:05:27Z", "hours": 7.6611, "text": "Hello Everyone! I have built this cute Waifu terminal AI with similar acronym to JARVIS. This isn’t any web app, it’s a TERMINAL app, so install exe, run it, test it, and enjoy it. I have added several features like voice changes, mood changes, conversation maintaining, etc. My MOTIVATION for building this- Getting more credits on Hackclub to get hardware for myself. So, support this one. Thanks All."}]...
|
Title: Gargi (Generally A Really Good Interface) b Title: Gargi (Generally A Really Good Interface) by @Techiral | Stardance
Devlogs:
Hello Everyone! I have built this cute Waifu terminal AI with similar acronym to JARVIS. This isn’t any web app, it’s a TERMINAL app, so install exe, run it, test it, and enjoy it. I have added several features like voice changes, mood changes, conversation maintaining, etc. My MOTIVATION for building this- Getting more credits on Hackclub to get hardware for myself. So, support this one. Thanks All.
Ships:
I made this with a basic problem in my mind, “Each AI terminal agent is built for developers, not teenagers”. The teenagers need something fun, personal, so I built this terminal agent. And, second motivation is to get credits in Stardance to earn & claim some hardware....
|
1793217008.510212
|
1793303408.510212
|
|
66764
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868045.0329804
|
1793732045.0329804
|
|
66765
|
SealDeck: my very first hackpad by @pcsef40 | Star SealDeck: my very first hackpad by @pcsef40 | Stardance...
|
pcsef40
|
0
|
0.77
|
0
|
[]
|
[{"post_id": 75702, "ts": "202 [{"post_id": 75702, "ts": "2026-09-30T19:54:31Z", "hours": 0.7661, "text": "sealdeck: The design is ready, the pcb board is made, and the code is almost done. planning on making big improvements on this little fella"}]...
|
Title: SealDeck: my very first hackpad by @pcsef40 Title: SealDeck: my very first hackpad by @pcsef40 | Stardance
Devlogs:
sealdeck: The design is ready, the pcb board is made, and the code is almost done. planning on making big improvements on this little fella...
|
1793101957.3788996
|
1793706757.3788996
|
|
66766
|
Quantar by @Systemic_speed | Stardance
|
Systemic_speed
|
0
|
42.5
|
0
|
[]
|
[{"post_id": 82635, "ts": "202 [{"post_id": 82635, "ts": "2026-10-25T14:01:20Z", "hours": 1.5508, "text": "Devlog 7: Quantar hey there, for anyone new here, Quantar is a superset of python that can: run quantum simulations (those superposition thingies that can speed up math) run some physics allow you to make your own operators What we got guys, this is the LAST DEVLOG BEFORE SHIP , so we have got some basic stuff to recap on: we got an extension for Quantar (see it on the marketplace here ), still haven’t got a logo for it and the language I am currently learning rust to use it as the new backend of this language (since rust is way faster and has better memory management, so no segfaults) kinda small change, but we now are using uuid to identify functions well, see y’all at ship. (btw here is me realizing that i cut my pypirc instead of copying it when i was planning to change to linux)"}, {"post_id": 82187, "ts": "2026-10-24T06:20:50Z", "hours": 8.5667, "text": "Devlog 6: Quantar hey there, for anyone new here, Quantar is a superset of python that can: run quantum simulations (those superposition thingies that can speed up math) run some physics allow you to make your own operators What we got We got, some news, QUANTAR CAN RUN ON ANY COMPUTER WITH PYTHON AND 8 GIGS OF RAM!!!! now, it is time for me to try and speedrun making the lsp (which is actually just a ton of json, js and other stuff), which will color the code. Next steps Complete the LSP SHIP THAT THING BEFORE HALLOWEEN make a rust backend in a later program (coral ig??) so, see ya all either at ship or in the next devlog (btw, here is Quantar code running)"}, {"post_id": 81212, "ts": "2026-10-20T10:02:34Z", "hours": 7.0942, "text": "Devlog 5: Quantar hey there, for anyone new here, Quantar is a quantum programming language that allows its users to : use and easily control quantum stuff like qubits or gates use some cool physics stuff (in progress, gotta complete it fast) INFINITE OPERATORS : basically, for any function you want as an operators, you just add a @operator(name, kind) (name is how the operator will be invoked and kind can be of 4 types: unary (currently prefix only), binary, matrix and a generic callable thing) and you can use it in your program as an operator. What happened well, I only realized yesterday that THERE IS ONE WEEK LEFT FOR STARDANCE, so i cobbled up a plan to finally ship Quantar. so today was just a basic debugging session where i just cleaned up a few files, refactored the code using AI (if you refactor code yourself, plz teach me how to manage the import trees for such projects) What next tomorrow, we are just gonna speedrun completing the physics part and the language part (the lexer and other stuff) well, see ya dead, alive or as a cat. (here is me trying to figure out why “000” can’t be used in dictionary keys (spoiler, you can use them, i was just an idiot))"}, {"post_id": 78719, "ts": "2026-10-11T12:11:27Z", "hours": 9.9817, "text": "Devlog 4: Quantar hey there, for anyone new here, Quantar is a python superset (basically a language that can do what python does but with more features) that I have been making that allows people to easily do cool physics and quantum simulations without using some insane quantum computer or something. well, we can kinda see the light at the end of the tunnel, as i have made the basic systems for the interpreter and also implemented the second most feature of this language, the @operator decorator (basically a small line of code you add right before the function definition that allow you to use that thing as an operator in Quantar). we also completed most of the standard library (the stl) by adding quantum optimization and some high level classes and methods for them now, we just gotta manage parematerized gates, make an AST, run the ast, make an extension and then we would be mostly done. btw here is me trying out a version of factoring that uses a quantum optimizer (it is kinda slow because simulating a 512 dimensional state vector along with crazy multiplication is very, very bad for my 8 gigs of DDR4)"}, {"post_id": 77863, "ts": "2026-10-08T16:13:16Z", "hours": 4.9781, "text": "Devlog 3: Quantar hey there, today was ok (maybe, but it was too much math). completed making an optimized model of shor’s algorithm (gonna stop the stupidly complex algorithms there, basically shor’s alg just factors a number FAST and grover’s algorithm find a number based on a function FAST) So, for anyone new here, Quantar is a python library (going to be a language) that allows people to use quantum computers, make physics simulations (and one more random feature that no language has ever done)or for the layman, it helps you do physics and quantum stuff easily and fast. What happened made an optimized version of both shor’s and grover’s algorithms (shor can factor 143 in 8 - 12 seconds). added composite gates and circuit gates (basically, ways to make gates out of gates like QFT or the iQFT) began planning for the physics part. now, for a kinda big reveal (ngl, gonna sound cringe), but the new feature i am adding to my lang is INFINITE OPERATOR OVERLOADS , basically, any character or combination of characters that can be typed using a keyboard (like a prefix * or <->) can be made into an operator that people can use. the last one will really either help people be creative with libraries or allow code to look clean (btw here is me trying out shor’s algorithm on 403, took some time, so gonna implement qunatum optimization algs later)"}, {"post_id": 76635, "ts": "2026-10-04T07:10:12Z", "hours": 5.1464, "text": "Devlog 2: Quantar hey there, today was actually ok (ish), i was able to implement Grover’s Algorithm (some complicated ahh stuff that takes in a constraint func and will give you a high chance of seeing that number when you measure the qubits in the computer) for anyone new here, Quantar is a python library (going to be a language) that allows people to use quantum computers, make physics simulations (and one more random feature that no language has ever done) or for the layman, it helps you do physics and quantum stuff easily and fast What’s next making some basic quantum algorithms making the physics backend making plotter abstractions adding a really cool feature (btw here is a photo of how insane Grover’s algorithm is (we wanted 111))"}, {"post_id": 76115, "ts": "2026-10-02T10:45:20Z", "hours": 5.1772, "text": "Devlog 1: Quantar Quantar is going to be a quantum programming language that can take in average python commands and would also be used for physics (like differentials, fields and maybe even nuclear physics). What I did today today was a kind of ok, i am mostly done with the basics of the quantum abstractions (qubits, quantum computers and quantum gates), just gotta complete testing and uncomputation. Next steps (basically a todo list for myself) making accurate and useful physics abstractions (like dual numbers for differentials or vector verlets and vector fields (really confusing stuff)) designing a proper syntax for Quantar (along with the compiler) Maybe some other stuff (gonna think about it today) well, here is me making the gate matrices for a few basic gates"}]...
|
Title: Quantar by @Systemic_speed | Stardance
Dev Title: Quantar by @Systemic_speed | Stardance
Devlogs:
Devlog 1: Quantar Quantar is going to be a quantum programming language that can take in average python commands and would also be used for physics (like differentials, fields and maybe even nuclear physics). What I did today today was a kind of ok, i am mostly done with the basics of the quantum abstractions (qubits, quantum computers and quantum gates), just gotta complete testing and uncomputation. Next steps (basically a todo list for myself) making accurate and useful physics abstractions (like dual numbers for differentials or vector verlets and vector fields (really confusing stuff)) designing a proper syntax for Quantar (along with the compiler) Maybe some other stuff (gonna think about it today) well, here is me making the gate matrices for a few basic gates
Devlog 2: Quantar hey there, today was actually ok (ish), i was able to implement Grover’s Algorithm (some complicated ahh stuff that takes in a constraint func and will give you a high chance of seeing that number when you measure the qubits in the computer) for anyone new here, Quantar is a python library (going to be a language) that allows people to use quantum computers, make physics simulations (and one more random feature that no language has ever done) or for the layman, it helps you do physics and quantum stuff easily and fast What’s next making some basic quantum algorithms making the physics backend making plotter abstractions adding a really cool feature (btw here is a photo of how insane Grover’s algorithm is (we wanted 111))
Devlog 3: Quantar hey there, today was ok (maybe, but it was too much math). completed making an optimized model of shor’s algorithm (gonna stop the stupidly complex algorithms there, basically shor’s alg just factors a number FAST and grover’s algorithm find a number based on a function FAST) So, for anyone new here, Quantar is a python library (going to be a language) that allows people to use quantum computers, make physics simulations (and one more random feature that no language has ever done)or for the layman, it helps you do physics and quantum stuff easily and fast. What happened made an optimized version of both shor’s and grover’s algorithms (shor can factor 143 in 8 - 12 seconds). added composite gates and circuit gates (basically, ways to make gates out of gates like QFT or the iQFT) began planning for the physics part. now, for a kinda big reveal (ngl, gonna sound cringe), but the new feature i am adding to my lang is INFINITE OPERATOR OVERLOADS , basically, any character or combination of characters that can be typed using a keyboard (like a prefix * or <->) can be made into an operator that people can use. the last one will really either help people be creative with libraries or allow code to look clean (btw here is me trying out shor’s algorithm on 403, took some time, so gonna implement qunatum optimization algs later)
Devlog 4: Quantar hey there, for anyone new here, Quantar is a python superset (basically a language that can do what python does but with more features) that I have been making that allows people to easily do cool physics and quantum simulations without using some insane quantum computer or something. well, we can kinda see the light at the end of the tunnel, as i have made the basic systems for the interpreter and also implemented the second most feature of this language, the @operator decorator (basically a small line of code you add right before the function definition that allow you to use that thing as an operator in Quantar). we also completed most of the standard library (the stl) by adding quantum optimization and some high level classes and methods for them now, we just gotta manage parematerized gates, make an AST, run the ast, make an extension and then we would be mostly done. btw here is me trying out a version of factoring that uses a quantum optimizer (it is kinda slow because simulating a 512 dimensional state vector along with crazy multiplication is very, very bad for my 8 gigs of DDR4)
Devlog 5: Quantar hey there, for anyone new here, Quantar is a quantum programming language that allows its users to : use and easily control quantum stuff like qubits or gates use some cool physics stuff (in progress, gotta complete it fast) INFINITE OPERATORS : basically, for any function you want as an operators, you just add a @operator(name, kind) (name is how the operator will be invoked and kind can be of 4 types: unary (currently prefix only), binary, matrix and a generic callable thing) and you can use it in your program as an operator. What happened well, I only realized yesterday that THERE IS ONE WEEK LEFT FOR STARDANCE, so i cobbled up a plan to finally ship Quantar. so today was just a basic debugging session where i just cleaned up a few files, refactored the code using AI (if you refactor code yourself, plz teach me how to manage the import trees for such projects) What next tomorrow, we are just gonna speedrun completing the physics part and the language part (the lexer and other stuff) well, see ya dead, alive or as a cat. (here is me trying to figure out why “000” can’t be used in dictionary keys (spoiler, you can use them, i was just an idiot))
Devlog 6: Quantar hey there, for anyone new here, Quantar is a superset of python that can: run quantum simulations (those superposition thingies that can speed up math) run some physics allow you to make your own operators What we got We got, some news, QUANTAR CAN RUN ON ANY COMPUTER WITH PYTHON AND 8 GIGS OF RAM!!!! now, it is time for me to try and speedrun making the lsp (which is actually just a ton of json, js and other stuff), which will color the code. Next steps Complete the LSP SHIP THAT THING BEFORE HALLOWEEN make a rust backend in a later program (coral ig??) so, see ya all either at ship or in the next devlog (btw, here is Quantar code running)
Devlog 7: Quantar hey there, for anyone new here, Quantar is a superset of python that can: run quantum simulations (those superposition thingies that can speed up math) run some physics allow you to make your own operators What we got guys, this is the LAST DEVLOG BEFORE SHIP , so we have got some basic stuff to recap on: we got an extension for Quantar (see it on the marketplace here ), still haven’t got a logo for it and the language I am currently learning rust to use it as the new backend of this language (since rust is way faster and has better memory management, so no segfaults) kinda small change, but we now are using uuid to identify functions well, see y’all at ship. (btw here is me realizing that i cut my pypirc instead of copying it when i was planning to change to linux)...
|
1793101959.1990452
|
1793706759.1990452
|
|
66767
|
Speech-Synthesiser by @ajmaleee__ | Stardance
|
ajmaleee__
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Speech-Synthesiser by @ajmaleee__ | Stardan Title: Speech-Synthesiser by @ajmaleee__ | Stardance...
|
1793101961.2342558
|
1793706761.2342558
|
|
66768
|
EXORBIT by @vishwakvemuru4u | Stardance
|
vishwakvemuru4u
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: EXORBIT by @vishwakvemuru4u | Stardance
|
1793101963.0012634
|
1793706763.0012634
|
|
66769
|
BLARE by @rainhassan | Stardance
|
rainhassan
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: BLARE by @rainhassan | Stardance
|
1793101964.7382293
|
1793706764.7382293
|
|
66770
|
My own site! by @Solans_jh07 | Stardance
|
Solans_jh07
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My own site! by @Solans_jh07 | Stardance
|
1793101965.6189997
|
1793706765.6189997
|
|
66771
|
1 macropad! by @amy_dz | Stardance
|
amy_dz
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: 1 macropad! by @amy_dz | Stardance
|
1793101967.1292725
|
1793706767.1292725
|
|
66772
|
wakey wakey by @cosmic79conqueror | Stardance
|
cosmic79conqueror
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: wakey wakey by @cosmic79conqueror | Stardan Title: wakey wakey by @cosmic79conqueror | Stardance...
|
1792461236.517616
|
1793325236.517616
|
|
66773
|
Rit by @pkriyam | Stardance
|
pkriyam
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Rit by @pkriyam | Stardance
|
1793101968.8938608
|
1793706768.8938608
|
|
66774
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868045.8388016
|
1793732045.8388016
|
|
66775
|
The Culinary Guide by @Nivedh_Govil | Stardance
|
Nivedh_Govil
|
1
|
2.0
|
3
|
[{"ship_num": 1, "ts": "2026-0 [{"ship_num": 1, "ts": "2026-09-30T16:10:09Z", "hours": 2.0, "multiplier": 1.51, "payout": 3, "blessing": "neutral", "text": "This project is a website that has three food items and their descriptions, with their recipes and how to make them. I decided to do something different this time, so I made it without CSS, and I also learned two new things in this project: making a progress bar and a dialog box, which used JavaScript. I also used HTML frames. There are three recipes, and you can see how to make them and their descriptions. I used a progress bar to show how difficult it was, as a rating out of 10, to cook them. I have deployed it using Vercel.", "repo": "https://github.com/NivedhGovil/Culinary-Guide", "demo": "https://culinaryguide-nivedh.vercel.app/"}]...
|
[{"post_id": 75616, "ts": "202 [{"post_id": 75616, "ts": "2026-09-30T15:48:45Z", "hours": 1.2417, "text": "Finally done with my website! Updates: Finalized the webpages for each food item. Added Images and made a new logo. New thing learnt: Progress bar and dialog box. Added instructions and steps to make each item. Hope this gets accepted for shipping! :D"}, {"post_id": 75245, "ts": "2026-09-29T15:49:02Z", "hours": 0.4425, "text": "Helloo! First day making a website. This time, the constraint is NO CSS! Only HTML and a little JavaScript. I am making a culinary guide that will have 3 or more recipes and their descriptions. I have an idea of using frames and something like that. Today I made the main page, and the 3 separate pages for each food item."}]...
|
Title: The Culinary Guide by @Nivedh_Govil | Stard Title: The Culinary Guide by @Nivedh_Govil | Stardance
Devlogs:
Helloo! First day making a website. This time, the constraint is NO CSS! Only HTML and a little JavaScript. I am making a culinary guide that will have 3 or more recipes and their descriptions. I have an idea of using frames and something like that. Today I made the main page, and the 3 separate pages for each food item.
Finally done with my website! Updates: Finalized the webpages for each food item. Added Images and made a new logo. New thing learnt: Progress bar and dialog box. Added instructions and steps to make each item. Hope this gets accepted for shipping! :D
Ships:
This project is a website that has three food items and their descriptions, with their recipes and how to make them. I decided to do something different this time, so I made it without CSS, and I also learned two new things in this project: making a progress bar and a dialog box, which used JavaScript. I also used HTML frames. There are three recipes, and you can see how to make them and their descriptions. I used a progress bar to show how difficult it was, as a rating out of 10, to cook them. I have deployed it using Vercel....
|
1793217010.4445431
|
1793303410.4445431
|
|
66776
|
cpio's web by @cpio | Stardance
|
cpio
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: cpio's web by @cpio | Stardance
|
1793101971.0659397
|
1793706771.0659397
|
|
66777
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868046.6669214
|
1793732046.6669214
|
|
66778
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868047.4818718
|
1793732047.4818718
|
|
66779
|
game by @amy_dz | Stardance
|
amy_dz
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: game by @amy_dz | Stardance
|
1793101971.9432406
|
1793706771.9432406
|
|
66780
|
My awesome macropad! by @SonamKumari | Stardance
|
SonamKumari
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My awesome macropad! by @SonamKumari | Star Title: My awesome macropad! by @SonamKumari | Stardance...
|
1793101973.9448965
|
1793706773.9448965
|
|
66781
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868048.2926333
|
1793732048.2926333
|
|
66782
|
WarioWare Game by @kolluruyuvankrishna | Stardance
|
kolluruyuvankrishna
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: WarioWare Game by @kolluruyuvankrishna | St Title: WarioWare Game by @kolluruyuvankrishna | Stardance...
|
1793101976.0146663
|
1793706776.0146663
|
|
66783
|
Problem solving network by @Bilisa | Stardance
|
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Problem solving network by @Bilisa | Starda Title: Problem solving network by @Bilisa | Stardance...
|
1793101978.0931697
|
1793706778.0931697
|
|
66784
|
My awesome macropad! by @Kaushikkk | Stardance
|
Kaushikkk
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My awesome macropad! by @Kaushikkk | Starda Title: My awesome macropad! by @Kaushikkk | Stardance...
|
1793101978.9421587
|
1793706778.9421587
|
|
66785
|
NASA Poster Generator by @Loiana-Lopes | Stardance
|
Loiana-Lopes
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: NASA Poster Generator by @Loiana-Lopes | St Title: NASA Poster Generator by @Loiana-Lopes | Stardance...
|
1793101982.2214549
|
1793706782.2214549
|
|
66786
|
My very own WebOS by @HARKIRAT | Stardance
|
HARKIRAT
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My very own WebOS by @HARKIRAT | Stardance
|
1793101984.033493
|
1793706784.033493
|
|
66787
|
Hand Tracking CODE by @Sumo | Stardance
|
Sumo
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Hand Tracking CODE by @Sumo | Stardance
|
1793101985.7782807
|
1793706785.7782807
|
|
66788
|
Personal Ai Assistant by @Xdreamninja | Stardance
|
Xdreamninja
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Personal Ai Assistant by @Xdreamninja | Sta Title: Personal Ai Assistant by @Xdreamninja | Stardance...
|
1793101987.5599854
|
1793706787.5599854
|
|
66789
|
Space OS by @arnavseth | Stardance
|
arnavseth
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Space OS by @arnavseth | Stardance
|
1793101989.2831047
|
1793706789.2831047
|
|
66790
|
MYPEROSNALWEBSITE@ by @rudranshjain | Stardance
|
rudranshjain
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: MYPEROSNALWEBSITE@ by @rudranshjain | Stard Title: MYPEROSNALWEBSITE@ by @rudranshjain | Stardance...
|
1793101991.0413675
|
1793706791.0413675
|
|
66791
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868049.1070936
|
1793732049.1070936
|
|
66792
|
PHY STUFF by @TXJ_PROGRAMER | Stardance
|
TXJ_PROGRAMER
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: PHY STUFF by @TXJ_PROGRAMER | Stardance
|
1793101992.767817
|
1793706792.767817
|
|
66793
|
My awesome macropad! by @Lizardy | Stardance
|
Lizardy
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My awesome macropad! by @Lizardy | Stardanc Title: My awesome macropad! by @Lizardy | Stardance...
|
1793101993.625773
|
1793706793.625773
|
|
66794
|
My awesome macropad! by @eshalzohaib370 | Stardanc My awesome macropad! by @eshalzohaib370 | Stardance...
|
eshalzohaib370
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My awesome macropad! by @eshalzohaib370 | S Title: My awesome macropad! by @eshalzohaib370 | Stardance...
|
1793101995.427622
|
1793706795.427622
|
|
66795
|
WarioWare Game by @Abhishekkhiladi69 | Stardance
|
Abhishekkhiladi69
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: WarioWare Game by @Abhishekkhiladi69 | Star Title: WarioWare Game by @Abhishekkhiladi69 | Stardance...
|
1793101997.4382513
|
1793706797.4382513
|
|
66796
|
My very own WebOS by @vihan_d26 | Stardance
|
vihan_d26
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My very own WebOS by @vihan_d26 | Stardance
|
1793101999.4924939
|
1793706799.4924939
|
|
66797
|
solar powered plant waterer by @eshalzohaib370 | S solar powered plant waterer by @eshalzohaib370 | Stardance...
|
eshalzohaib370
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: solar powered plant waterer by @eshalzohaib Title: solar powered plant waterer by @eshalzohaib370 | Stardance...
|
1793102000.3602824
|
1793706800.3602824
|
|
66798
|
Zero hour by @youngrich | Stardance
|
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Zero hour by @youngrich | Stardance
|
1793102005.4706953
|
1793706805.4706953
|
|
66799
|
Frictionless by @athrv | Stardance
|
athrv
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: Frictionless by @athrv | Stardance
|
1793102007.1979165
|
1793706807.1979165
|
|
66800
|
. by @eshalzohaib370 | Stardance
|
eshalzohaib370
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: . by @eshalzohaib370 | Stardance
|
1793102009.3161771
|
1793706809.3161771
|
|
66801
|
A webpage by @Blackboy | Stardance
|
Blackboy
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: A webpage by @Blackboy | Stardance
|
1793102011.4176555
|
1793706811.4176555
|
|
66802
|
My awesome macropad! by @fastxsonic675 | Stardance
|
fastxsonic675
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: My awesome macropad! by @fastxsonic675 | St Title: My awesome macropad! by @fastxsonic675 | Stardance...
|
1793102014.5374274
|
1793706814.5374274
|
|
66803
|
NULL
|
NULL
|
0
|
0.0
|
0
|
[]
|
[]
|
|
1792868056.01508
|
1793732056.01508
|
|
66804
|
A live sync notepad? Like a big platform for writi A live sync notepad? Like a big platform for writing? by @cobaltsplayground | Stardance...
|
cobaltsplayground
|
0
|
0.0
|
0
|
[]
|
[]
|
Title: A live sync notepad? Like a big platform fo Title: A live sync notepad? Like a big platform for writing? by @cobaltsplayground | Stardance...
|
1793102015.4143348
|
1793706815.4143348
|