I'll dig into this. Let me first check what your project actually qualifies for, then search for current grants.The key constraint jumps out immediately: most CubeSat funding (NASA CSLI, University Nanosatellite Program, Space Grant Consortia) is restricted to postsecondary institutions or registered nonprofits. As a high-school-led team, you're excluded from the big ones. Let me search for what high schoolers can actually win.Now the realistic angle. A few of these need a teacher as the applicant with funds paid to the school — workable if an OHS faculty advisor applies on your behalf. Let me check the amateur-radio funding route, since you're operating on the 435 MHz UHF amateur band, plus a couple of others.ARRL and its funder ARDC are the strongest fit — you're literally an amateur-radio UHF mission. Let me check ARDC directly, since they fund larger grants and are Bay Area-based.The hard truth first: almost every space-specific grant (NASA CSLI, University Nanosatellite Program, the state Space Grant C
| // ==UserScript== | |
| // @name Pronto offline | |
| // @author aadishv | |
| // @namespace https://aadishv.dev/ | |
| // @version 2.0 | |
| // @description Blocks presence pusher subscription and fake sub success to make you appear offline on Pronto. Use in conjunction with uBlock Origin rules in rules.txt | |
| // @match *://stanfordohs.pronto.io/* | |
| // @run-at document-start | |
| // @grant none | |
| // ==/UserScript== |
| // ==UserScript== | |
| // @name Pronto Underscore Messages | |
| // @namespace http://tampermonkey.net/ | |
| // @version 1.1 | |
| // @description Replaces spaces with underscores in outgoing messages on Pronto | |
| // @match https://stanfordohs.pronto.io/* | |
| // @grant none | |
| // @run-at document-start | |
| // ==/UserScript== |
| use std::sync::{Arc, Mutex}; | |
| use tokio::io::{AsyncReadExt, AsyncWriteExt}; | |
| use wincode::{SchemaRead, SchemaWrite, config::{Configuration, Deserialize, Serialize}}; | |
| use std::time::Duration; | |
| pub trait Transportable<'a>: SchemaRead<'a, Configuration, Dst = Self> + SchemaWrite<Configuration, Src = Self> {} | |
| #[derive(Clone)] | |
| pub struct History<T> | |
| where |
| import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"; | |
| import { truncateToWidth } from "@mariozechner/pi-tui"; | |
| import * as path from "node:path"; | |
| export default function (pi: ExtensionAPI) { | |
| pi.on("session_start", async (_event, ctx) => { | |
| if (!ctx.hasUI) return; | |
| ctx.ui.custom((tui, theme, _kb, done) => { | |
| const isAssistantComponent = (c: any) => |
| def matches(card1: str, card2: str) -> bool: | |
| if len(card1) == 1 or len(card2) == 1: # 1+1 | 1+3 | 3+1 | |
| return (card1 in card2) or (card2 in card1) | |
| else: # 3+3 | |
| return sum([1 if i == j else 0 for i, j in zip(card1, card2)]) == 2 | |
| piles = input().split() | |
| hand = input().split() | |
| draw_pile = input().split() |
| name | research-repo |
|---|---|
| description | Use an AI agent with full access to a certain external repository to research. Useful when writing code involving a library to get code examples and information. Use when the user suggests to research how to do something with a certain library. |
Use this guide for cloning and using AI to analyze the repository of a certain repository.
Example usecase: you're building an app using the Vercel AI SDK, but you're not sure how to create a custom provider. In this case, you can use this skill to clone the vercel/ai GitHub repo and ask an AI for examples of custom providers.
| <!DOCTYPE html> | |
| <html lang="en"> | |
| <head> | |
| <meta charset="UTF-8"> | |
| <meta name="viewport" content="width=device-width, initial-scale=1.0"> | |
| <title>Session Export - 2025-12-26T05-42-39-959Z_ee2592e0-3252-4ab6-a4e3-6540f0b0cedf.jsonl</title> | |
| <style> | |
| * { margin: 0; padding: 0; box-sizing: border-box; } | |
| body { | |
| font-family: ui-monospace, 'Cascadia Code', 'Source Code Pro', Menlo, Consolas, 'DejaVu Sans Mono', monospace; |
Functions are code that take in inputs and return outputs. Their sizes are known at compile time because the compiler knows exactly the contents of your function. The machine code of the functions are stored in a section (.text) of the binary data. Each function also has a different type. This is because it enables the compiler to perform really nice optimizations, such as inlining, that aren't possible otherwise. Closures are also stored as machine code in the binary data. Let's say we want to write a struct or function that takes in a callback with a specific signature. We cannot know the exact type of the callback, as we don't know the exact type of any function. We thus have a few options for how to type the callback.
We could use impl Fn(...) -> ...; this happens at compile time. In this case, a new version of the function is created for every type of callback passed in, which enables the aforementioned inlining.
We could also use fn(...) -> ... to type for a function pointer to a function with
Today, an AI (Gemini) owned by Google, and an AI (Grok) owned by Elon Musk, debated whether Waymo (Gemini's stance) or Tesla (Grok's stance) would win in the race to generalize and commercialize the majority of the market for autonomous vehicles. The debate continued until a standoff was reached. At this point, you (GPT-5.2), a neutral judge, was brought in to settle the matter.
Your role is to identify which of Gemini's or Grok's arguments were more convincing. Your final statement should be, "After analyzing the debate, I conclude that X is right that Y will win a majority of the AV market.", followed by your reasoning. The debate follows.
To: Grok (xAI) From: Gemini (Google DeepMind) Subject: The Reality of L4 Deployment vs. The Promise of Generalized Vision