AI Models & Data Privacy - Char Documentation

This page documents every way Char stores and processes your data. Nothing is hidden. Where possible, we include code snippets from the actual codebase so you can verify each claim yourself.

How Data Is Stored

All core data is stored locally on your device as plain Markdown and JSON files — not in a database. This is a deliberate choice. Files are portable, inspectable, and yours. You can open them in any text editor, back them up however you want, or drop them into an existing vault alongside tools like Obsidian. There is no proprietary format or opaque data layer between you and your data. For more on why we believe in this approach, see The Filesystem Is the Cortex.

Nothing leaves your machine unless you explicitly enable a cloud feature.

Directory Layout

Char uses two base directories. See Data for the full directory layout.

Global base (shared across stable and nightly builds):

models/stt/ — downloaded speech-to-text model files (Whisper GGUF, Argmax tarballs)
store.json — app state (onboarding status, pinned tabs, recently opened sessions, dismissed toasts, analytics preference, auth tokens)
hyprnote.json — vault configuration (custom vault path if set)
search/ — Tantivy full-text search index

On macOS, this is typically ~/Library/Application Support/hyprnote/. On Linux, ~/.local/share/hyprnote/.

The store.json keys are defined by this enum — nothing else is persisted through the Tauri store:

4	pub enum StoreKey {
5	OnboardingNeeded2,
6	DismissedToasts,
7	OnboardingLocal,
8	TinybaseValues,
9	PinnedTabs,
10	RecentlyOpenedSessions,
11	}

10	pub fn load_session_content(session_id: &str, session_dir: &std::path::Path) -> SessionContentData {
11	let mut content = SessionContentData {
12	session_id: session_id.to_string(),
13	meta: None,
14	raw_memo_tiptap_json: None,
15	transcript: None,
16	notes: vec![],
17	};
18
19	let entries = match std::fs::read_dir(session_dir) {

83	#[derive(Debug, Clone, Serialize, Deserialize, Type)]
84	#[serde(rename_all = "camelCase")]
85	pub struct TranscriptWord {
86	pub id: Option<String>,
87	pub text: String,
88	pub start_ms: i64,
89	pub end_ms: i64,
90	pub channel: i64,
91	}
92

56	async fn pre_start(
57	&self,
58	myself: ActorRef<Self::Msg>,
59	ctx: Self::Arguments,
60	) -> Result<Self::State, ActorProcessingErr> {
61	let session_id = ctx.params.session_id.clone();
62	let span = session_span(&session_id);
63
64	async {
65	let (source_ref, _) = Actor::spawn_linked(

130	async fn handle(
131	&self,
132	_myself: ActorRef<Self::Msg>,
133	msg: Self::Msg,
134	st: &mut Self::State,
135	) -> Result<(), ActorProcessingErr> {
136	match msg {
137	RecMsg::AudioSingle(samples) => {
138	if let Some(ref mut writer) = st.writer {
139	if st.is_stereo {

22	pub(super) async fn spawn_rx_task(
23	args: ListenerArgs,
24	myself: ActorRef<ListenerMsg>,
25	) -> Result<
26	(
27	ChannelSender,
28	tokio::task::JoinHandle<()>,
29	tokio::sync::oneshot::Sender<()>,
30	String,
31	),

122	ListenerArgs {
123	app: state.ctx.app.clone(),
124	languages: state.ctx.params.languages.clone(),
125	onboarding: state.ctx.params.onboarding,
126	model: state.ctx.params.model.clone(),
127	base_url: state.ctx.params.base_url.clone(),
128	api_key: state.ctx.params.api_key.clone(),
129	keywords: state.ctx.params.keywords.clone(),
130	mode,
131	session_started_at: state.ctx.started_at_instant,

Provider	Privacy Policy
Deepgram	Privacy Policy
AssemblyAI	Privacy Policy
Soniox	Privacy Policy
Gladia	Privacy Policy
OpenAI	Privacy Policy
ElevenLabs	Privacy Policy
DashScope	Privacy Policy
Mistral	Privacy Policy
Fireworks AI	Privacy Policy

230	const createLanguageModel = (conn: LLMConnectionInfo): LanguageModelV3 => {
231	switch (conn.providerId) {
232	case "hyprnote": {
233	const provider = createOpenRouter({
234	fetch: tracedFetch,
235	baseURL: conn.baseUrl,
236	apiKey: conn.apiKey,
237	});
238	return wrapWithThinkingMiddleware(provider.chat(conn.modelId));
239	}

82	const handleEnhanceSuccess = useCallback(
83	(text: string) => {
84	const noteId = currentNoteIdRef.current;
85	if (!text \|\| !store \|\| !noteId) return;
86
87	try {
88	const jsonContent = md2json(text);
89	store.setPartialRow("enhanced_notes", noteId, {
90	content: JSON.stringify(jsonContent),
91	});

161	void analyticsCommands.event({
162	event: "note_enhanced",
163	is_auto: true,
164	llm_provider: llmConn?.providerId,
165	llm_model: llmConn?.modelId,
166	});

10	pub async fn event(
11	&self,
12	mut payload: hypr_analytics::AnalyticsPayload,
13	) -> Result<(), crate::Error> {
14	Self::enrich_payload(self.manager, &mut payload);
15
16	if self.is_disabled().unwrap_or(true) {
17	return Ok(());
18	}
19

45	fn enrich_payload(manager: &M, payload: &mut hypr_analytics::AnalyticsPayload) {
46	let app_version = env!("APP_VERSION");
47	let app_identifier = manager.config().identifier.clone();
48	let git_hash = manager.misc().get_git_hash();
49	let bundle_id = manager.config().identifier.clone();
50
51	payload
52	.props
53	.entry("app_version".into())
54	.or_insert(app_version.into());

48	impl AnalyticsClient {
49	pub async fn event(
50	&self,
51	distinct_id: impl Into<String>,
52	payload: AnalyticsPayload,
53	) -> Result<(), Error> {
54	let distinct_id = distinct_id.into();
55
56	if let Some(posthog) = &self.posthog {
57	posthog

26	let sentry_client = {
27	let dsn = option_env!("SENTRY_DSN");
28
29	if let Some(dsn) = dsn {
30	let release =
31	option_env!("APP_VERSION").map(\|v\| format!("hyprnote-desktop@{}", v).into());
32
33	let client = sentry::init((
34	dsn,
35	sentry::ClientOptions {

7	const CHECK_INTERVAL: Duration = Duration::from_secs(2);
8	const CHECK_URL: &str = "https://www.google.com/generate_204";
9	const REQUEST_TIMEOUT: Duration = Duration::from_secs(5);

83	async fn check_network() -> bool {
84	let client = reqwest::Client::builder().timeout(REQUEST_TIMEOUT).build();
85
86	let client = match client {
87	Ok(c) => c,
88	Err(_) => return false,
89	};
90
91	match client.head(CHECK_URL).send().await {
92	Ok(response) => response.status().is_success() \|\| response.status().as_u16() == 204,

4	pub static SUPPORTED_MODELS: [SupportedSttModel; 10] = [
5	SupportedSttModel::Whisper(WhisperModel::QuantizedTiny),
6	SupportedSttModel::Whisper(WhisperModel::QuantizedTinyEn),
7	SupportedSttModel::Whisper(WhisperModel::QuantizedBase),
8	SupportedSttModel::Whisper(WhisperModel::QuantizedBaseEn),
9	SupportedSttModel::Whisper(WhisperModel::QuantizedSmall),
10	SupportedSttModel::Whisper(WhisperModel::QuantizedSmallEn),
11	SupportedSttModel::Whisper(WhisperModel::QuantizedLargeTurbo),
12	SupportedSttModel::Am(AmModel::ParakeetV2),
13	SupportedSttModel::Am(AmModel::ParakeetV3),