2026-10-11 13:22:55 +00:00
16 changed files with 493 additions and 63 deletions
@@ -4515,11 +4515,13 @@ version = "1.0.2"
 dependencies = [
 "anyhow",
 "chat",
+ "common",
 "flume 0.11.1",
 "futures",
 "gpui-pre",
 "log",
 "nostr-sdk",
+ "person",
 "serde_json",
 "smallvec",
 "state",
@@ -1,7 +1,7 @@
 use std::hash::Hash;
 use std::ops::Range;

-use common::{EventExt, NostrParser, extract_and_remove_media_urls};
+use common::{EventExt, NostrParser, emojis_from_tags, extract_and_remove_media_urls};
 use gpui::{SharedString, SharedUri};
 use nostr_sdk::prelude::*;
 use state::FileAttachment;
@@ -22,6 +22,8 @@ pub struct Message {
    pub created_at: Timestamp,
    /// List of mentioned public keys in the message
    pub mentions: Vec<Mention>,
+    /// Custom emoji (NIP-30) declared by this message's `emoji` tags
+    pub emojis: Vec<(String, Url)>,
    /// List of event of the message this message is a reply to
    pub replies_to: Vec<EventId>,
    /// Encrypted file attachment
@@ -85,6 +87,7 @@ fn from_parts(
    let has_file = file.is_some();

    let replies_to = extract_reply_ids(tags);
+    let emojis = emojis_from_tags(tags);

    // For file messages `.content` is the encrypted blob URL, not text or media
    let mentions = if has_file {
@@ -106,6 +109,7 @@ fn from_parts(
        media,
        created_at,
        mentions,
+        emojis,
        replies_to,
        file,
    }
@@ -146,6 +150,13 @@ impl Message {

        self.content.clone().into()
    }
+
+    /// Image URL of a `:shortcode:` reaction, if the shortcode is declared
+    pub fn reaction_image(content: &str, emojis: &[(String, Url)]) -> Option<Url> {
+        let shortcode = content.strip_prefix(':')?.strip_suffix(':')?;
+        let (_, url) = emojis.iter().find(|(name, _)| name == shortcode)?;
+        Some(url.clone())
+    }
 }

 /// New message.
@@ -226,3 +237,50 @@ fn extract_reply_ids(inner: &Tags) -> Vec<EventId> {

    replies_to
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rumor(kind: Kind, content: &str, tags: Tags) -> UnsignedEvent {
+        let sender = Keys::generate();
+
+        let mut rumor = EventBuilder::new(kind, content)
+            .tags(tags)
+            .finalize_unsigned(sender.public_key());
+        rumor.ensure_id();
+        rumor
+    }
+
+    fn emoji_tag(shortcode: &str, url: &str) -> Tag {
+        Tag::parse(vec!["emoji", shortcode, url]).expect("valid emoji tag")
+    }
+
+    #[test]
+    fn message_parses_emoji_tags() {
+        let tags = Tags::from_list(vec![emoji_tag(
+            "soapbox",
+            "https://example.com/soapbox.png",
+        )]);
+
+        let message = Message::from(&rumor(Kind::PrivateDirectMessage, "hi :soapbox:", tags));
+
+        assert_eq!(message.emojis.len(), 1);
+        assert_eq!(message.emojis[0].0, "soapbox");
+    }
+
+    #[test]
+    fn reaction_image_matches_declared_shortcode() {
+        let emojis = vec![(
+            String::from("soapbox"),
+            Url::parse("https://example.com/soapbox.png").unwrap(),
+        )];
+
+        assert_eq!(
+            Message::reaction_image(":soapbox:", &emojis),
+            Some(Url::parse("https://example.com/soapbox.png").unwrap())
+        );
+        assert_eq!(Message::reaction_image("😂", &emojis), None);
+        assert_eq!(Message::reaction_image(":unknown:", &emojis), None);
+    }
+}
@@ -405,8 +405,11 @@ impl Room {

        // Construct a direct message rumor event
        // WARNING: never sign and send this event to relays
+        let mut tags = self.conversation_tags(&replies, sender, cx);
+        tags.extend(PersonRegistry::emoji_tags(&content, cx));
+
        let mut event = EventBuilder::new(kind, content)
-            .tags(self.conversation_tags(&replies, sender, cx))
+            .tags(tags)
            .finalize_unsigned(sender);

        // Ensure that the ID is set
@@ -6,7 +6,7 @@ use settings::SignerKind;
 #[derive(Action, Clone, PartialEq, Eq, Deserialize)]
 #[action(namespace = chat, no_json)]
 pub enum Command {
-    Insert(&'static str),
+    Insert(String),
    ChangeSubject(String),
    ChangeSigner(SignerKind),
    ToggleBackup,
@@ -5,14 +5,15 @@ use std::sync::{Arc, LazyLock, RwLock};
 pub use actions::*;
 use anyhow::Error;
 use chat::{ChatRegistry, Message, Room, RoomEvent, SendReport};
-use common::TimestampExt;
+use common::{TimestampExt, emojis_from_tags};
 use gpui::prelude::FluentBuilder;
 use gpui::{
    AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
    Focusable, InteractiveElement, IntoElement, ListAlignment, ListOffset, ListState, MouseButton,
-    ObjectFit, ParentElement, PathPromptOptions, Render, SharedString, StatefulInteractiveElement,
-    Styled, StyledImage, Subscription, SystemNotification, SystemNotificationAction, Task,
-    WeakEntity, Window, div, img, list, px, red, relative, retain_all, svg, white,
+    ObjectFit, ParentElement, PathPromptOptions, Render, SharedString, SharedUri,
+    StatefulInteractiveElement, Styled, StyledImage, Subscription, SystemNotification,
+    SystemNotificationAction, Task, WeakEntity, Window, div, img, list, px, red, relative,
+    retain_all, svg, white,
 };
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
@@ -52,6 +53,10 @@ const PRIVATE_NOTICE: &str =
 static EMOJI_RE: LazyLock<Regex> =
    LazyLock::new(|| Regex::new(r"^[\p{Emoji}\u{200D}\u{FE0F}\u{20E3}]+$").unwrap());

+/// Regex matching a single custom emoji reference, like `:soapbox:`
+static CUSTOM_EMOJI_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^:[A-Za-z0-9_-]+:$").unwrap());
+
 mod actions;
 mod file;
 pub mod text;
@@ -78,7 +83,7 @@ pub struct ChatPanel {
    message_index: HashMap<EventId, usize>,

    /// All reactions
-    reactions: BTreeMap<EventId, Vec<(SharedString, PublicKey)>>,
+    reactions: BTreeMap<EventId, Vec<(SharedString, Option<SharedUri>, PublicKey)>>,

    /// Mapping message ids to their rendered texts
    rendered_texts_by_id: BTreeMap<EventId, RenderedText>,
@@ -330,7 +335,7 @@ impl ChatPanel {
        // If replying to exactly one message with only a valid emoji,
        // send as a reaction instead of a text message
        if replies.len() == 1
-            && EMOJI_RE.is_match(&content)
+            && (EMOJI_RE.is_match(&content) || CUSTOM_EMOJI_RE.is_match(&content))
            && self.attachments.read(cx).is_empty()
            && files.is_empty()
        {
@@ -535,11 +540,16 @@ impl ChatPanel {
            return;
        }

+        let emojis = emojis_from_tags(&event.tags);
+        let image = Message::reaction_image(&event.content, &emojis)
+            .map(|url| SharedUri::from(url.to_string()));
+
        for id in event.tags.event_ids() {
-            self.reactions
-                .entry(id)
-                .or_default()
-                .push((SharedString::from(&event.content), event.pubkey));
+            self.reactions.entry(id).or_default().push((
+                SharedString::from(&event.content),
+                image.clone(),
+                event.pubkey,
+            ));
        }

        cx.notify();
@@ -563,7 +573,7 @@ impl ChatPanel {
    }

    /// Get a reaction by its target ID (returns reference, no allocation)
-    fn reaction(&self, id: &EventId) -> &[(SharedString, PublicKey)] {
+    fn reaction(&self, id: &EventId) -> &[(SharedString, Option<SharedUri>, PublicKey)] {
        self.reactions.get(id).map(|v| v.as_slice()).unwrap_or(&[])
    }

@@ -1081,7 +1091,13 @@ impl ChatPanel {
                .rendered_texts_by_id
                .entry(message.id)
                .or_insert_with(|| {
-                    text::rendered_text(&message.content, &message.mentions, &persons, cx)
+                    text::rendered_text(
+                        &message.content,
+                        &message.mentions,
+                        &message.emojis,
+                        &persons,
+                        cx,
+                    )
                })
                .element(ix.into(), window, cx);

@@ -1741,15 +1757,23 @@ impl ChatPanel {
            })
    }

-    fn render_emoji_menu(&self, _window: &Window, _cx: &Context<Self>) -> impl IntoElement {
+    fn render_emoji_menu(&self, _window: &Window, cx: &Context<Self>) -> impl IntoElement {
+        let emojis = PersonRegistry::current_emojis(cx);
+
        Button::new("emoji")
            .icon(IconName::Emoji)
            .ghost()
            .large()
            .dropdown_menu_with_anchor(gpui::Anchor::BottomLeft, move |this, _window, _cx| {
-                let menu = this.horizontal();
-                REACTION_EMOJIS.iter().fold(menu, |this, emoji| {
-                    this.menu(*emoji, Box::new(Command::Insert(emoji)))
+                let menu = REACTION_EMOJIS
+                    .iter()
+                    .fold(this.horizontal(), |this, emoji| {
+                        this.menu(*emoji, Box::new(Command::Insert(emoji.to_string())))
+                    });
+
+                emojis.iter().fold(menu, |this, (shortcode, _)| {
+                    let label = format!(":{shortcode}:");
+                    this.menu(label.clone(), Box::new(Command::Insert(label)))
                })
            })
    }
@@ -1,17 +1,18 @@
 use chat::Mention;
 use gpui::{App, Entity};
+use nostr_sdk::prelude::Url;
 use person::PersonRegistry;
 use ui::markdown::InlineReplacement;
 pub use ui::markdown::RenderedText;

-/// Render message `content`, replacing mentions with their display names.
 pub fn rendered_text(
    content: &str,
    mentions: &[Mention],
+    emojis: &[(String, Url)],
    persons: &Entity<PersonRegistry>,
    cx: &App,
 ) -> RenderedText {
-    let replacements = mentions
+    let mut replacements = mentions
        .iter()
        .map(|mention| {
            InlineReplacement::new(
@@ -21,5 +22,62 @@ pub fn rendered_text(
        })
        .collect::<Vec<_>>();

+    replacements.extend(emoji_replacements(content, emojis));
+    replacements.sort_by_key(|replacement| replacement.range.start);
+
    RenderedText::new(content, &replacements)
 }
+
+fn emoji_replacements(content: &str, emojis: &[(String, Url)]) -> Vec<InlineReplacement> {
+    let mut replacements = Vec::new();
+
+    for (shortcode, url) in emojis {
+        let pattern = format!(":{shortcode}:");
+        for (start, _) in content.match_indices(&pattern) {
+            let range = start..start + pattern.len();
+
+            // Skip matches glued to word characters, like the `30` in `12:30:45`
+            if content[..start].ends_with(char::is_alphanumeric)
+                || content[range.end..].starts_with(char::is_alphanumeric)
+            {
+                continue;
+            }
+
+            replacements.push(InlineReplacement::image(
+                range,
+                shortcode.clone(),
+                url.to_string(),
+            ));
+        }
+    }
+
+    replacements
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn emoji(shortcode: &str, url: &str) -> (String, Url) {
+        (String::from(shortcode), Url::parse(url).expect("valid url"))
+    }
+
+    #[test]
+    fn declared_shortcodes_become_image_replacements() {
+        let emojis = vec![emoji("soapbox", "https://example.com/soapbox.png")];
+
+        let replacements = emoji_replacements("hi :soapbox: and :other:", &emojis);
+
+        assert_eq!(replacements.len(), 1);
+        assert_eq!(replacements[0].range, 3..12);
+    }
+
+    #[test]
+    fn matches_glued_to_word_characters_are_skipped() {
+        let emojis = vec![emoji("30", "https://example.com/30.png")];
+
+        assert!(emoji_replacements("at 12:30:45 exactly", &emojis).is_empty());
+        assert!(emoji_replacements("x:30: and :30:y", &emojis).is_empty());
+        assert_eq!(emoji_replacements("(:30:)", &emojis).len(), 1);
+    }
+}
@@ -51,3 +51,53 @@ impl EventExt for UnsignedEvent {
        public_keys.into_iter().unique().sorted().collect()
    }
 }
+
+/// Custom emoji (NIP-30) declared by `emoji` tags, first per shortcode wins
+pub fn emojis_from_tags(tags: &Tags) -> Vec<(String, Url)> {
+    let mut emojis: Vec<(String, Url)> = Vec::new();
+
+    for tag in tags.iter() {
+        let Ok(Nip30Tag::Emoji {
+            shortcode,
+            image_url,
+            ..
+        }) = Nip30Tag::try_from(tag)
+        else {
+            continue;
+        };
+
+        if !emojis.iter().any(|(existing, _)| *existing == shortcode) {
+            emojis.push((shortcode, image_url));
+        }
+    }
+
+    emojis
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn emojis_from_tags_parses_and_deduplicates() {
+        let tags = Tags::from_list(vec![
+            Tag::parse(vec!["emoji", "soapbox", "https://example.com/soapbox.png"]).unwrap(),
+            Tag::parse(vec!["emoji", "soapbox", "https://example.com/other.png"]).unwrap(),
+            Tag::parse(vec![
+                "emoji",
+                "bad shortcode",
+                "https://example.com/bad.png",
+            ])
+            .unwrap(),
+        ]);
+
+        let emojis = emojis_from_tags(&tags);
+
+        assert_eq!(emojis.len(), 1);
+        assert_eq!(emojis[0].0, "soapbox");
+        assert_eq!(
+            emojis[0].1,
+            Url::parse("https://example.com/soapbox.png").unwrap()
+        );
+    }
+}
@@ -10,6 +10,8 @@ anyhow.workspace = true
 futures.workspace = true
 serde_json.workspace = true
 state = { path = "../state" }
+common = { path = "../common" }
+person = { path = "../person" }
 chat = { path = "../chat" }

 gpui.workspace = true
@@ -3,8 +3,10 @@ use std::time::Duration;

 use anyhow::{Result, anyhow, bail};
 use chat::Message;
-use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
+use common::emojis_from_tags;
+use gpui::{App, AppContext, Context, EventEmitter, SharedString, SharedUri, Task};
 use nostr_sdk::prelude::*;
+use person::PersonRegistry;
 use smallvec::{SmallVec, smallvec};
 use state::NostrRegistry;

@@ -31,6 +33,7 @@ enum Absorbed {
 pub struct Reaction {
    pub id: EventId,
    pub emoji: String,
+    pub image: Option<SharedUri>,
    pub author: PublicKey,
 }

@@ -233,7 +236,11 @@ impl Group {
        replies: Vec<EventId>,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
-        self.dispatch(move |id, prev| id.message(content, &replies, prev), cx)
+        let emojis = PersonRegistry::emoji_tags(content, cx);
+        self.dispatch(
+            move |id, prev| id.message(content, &replies, &emojis, prev),
+            cx,
+        )
    }

    pub fn send_reaction(
@@ -242,7 +249,11 @@ impl Group {
        emoji: String,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
-        self.dispatch(move |id, prev| id.reaction(target, &emoji, prev), cx)
+        let emojis = PersonRegistry::emoji_tags(&emoji, cx);
+        self.dispatch(
+            move |id, prev| id.reaction(target, &emoji, &emojis, prev),
+            cx,
+        )
    }

    pub fn remove_user(
@@ -756,9 +767,14 @@ impl Group {
            return false;
        }

+        let emojis = emojis_from_tags(&event.tags);
+        let image = Message::reaction_image(&event.content, &emojis)
+            .map(|url| SharedUri::from(url.to_string()));
+
        self.reactions.entry(target).or_default().push(Reaction {
            id: event.id,
            emoji: event.content.clone(),
+            image,
            author: event.pubkey,
        });

@@ -110,18 +110,27 @@ impl GroupId {
        &self,
        content: &str,
        replies: &[EventId],
+        emojis: &[Tag],
        previous: Option<Tag>,
    ) -> EventBuilder {
        EventBuilder::new(Kind::ChatMessage, content)
            .tag(self.h_tag())
            .tags(replies.iter().copied().map(Tag::event))
+            .tags(emojis.iter().cloned())
            .tag_maybe(previous)
    }

-    pub fn reaction(&self, target: EventId, emoji: &str, previous: Option<Tag>) -> EventBuilder {
+    pub fn reaction(
+        &self,
+        target: EventId,
+        emoji: &str,
+        emojis: &[Tag],
+        previous: Option<Tag>,
+    ) -> EventBuilder {
        EventBuilder::new(Kind::Reaction, emoji)
            .tag(self.h_tag())
            .tag(Tag::event(target))
+            .tags(emojis.iter().cloned())
            .tag_maybe(previous)
    }

@@ -886,7 +886,15 @@ impl GroupPanel {
        let content = self
            .rendered_texts_by_id
            .entry(message.id)
-            .or_insert_with(|| rendered_text(&message.content, &message.mentions, &persons, cx))
+            .or_insert_with(|| {
+                rendered_text(
+                    &message.content,
+                    &message.mentions,
+                    &message.emojis,
+                    &persons,
+                    cx,
+                )
+            })
            .element(ix.into(), window, cx);

        let admin = nostr
@@ -43,9 +43,13 @@ pub(crate) fn render(
    let author = persons.read(cx).get(&message.author, cx);

    let reaction_groups = group_reactions(
-        reactions
-            .iter()
-            .map(|reaction| (SharedString::from(reaction.emoji.as_str()), reaction.author)),
+        reactions.iter().map(|reaction| {
+            (
+                SharedString::from(reaction.emoji.as_str()),
+                reaction.image.clone(),
+                reaction.author,
+            )
+        }),
        nostr.read(cx).current_user(),
    );

@@ -100,7 +104,7 @@ pub(crate) fn render(
                    let group = group.clone();
                    let panel = panel.clone();

-                    move |menu, _window, _cx| react_menu(menu, group.clone(), panel.clone(), id)
+                    move |menu, _window, cx| react_menu(menu, group.clone(), panel.clone(), id, cx)
                });

            if !admin {
@@ -140,8 +144,9 @@ fn react_menu(
    group: WeakEntity<Group>,
    panel: WeakEntity<GroupPanel>,
    id: EventId,
+    cx: &App,
 ) -> PopupMenu {
-    REACTIONS.iter().fold(menu, |menu, emoji| {
+    let menu = REACTIONS.iter().fold(menu, |menu, emoji| {
        let emoji = *emoji;
        let group = group.clone();
        let panel = panel.clone();
@@ -155,6 +160,28 @@ fn react_menu(
                }
            }),
        )
+    });
+
+    let emojis = PersonRegistry::current_emojis(cx);
+    if emojis.is_empty() {
+        return menu;
+    }
+
+    let menu = menu.separator();
+    emojis.into_iter().fold(menu, |menu, (shortcode, _)| {
+        let emoji = format!(":{shortcode}:");
+        let group = group.clone();
+        let panel = panel.clone();
+
+        menu.item(
+            PopupMenuItem::new(emoji.clone()).on_click(move |_event, _window, cx| {
+                if let Err(error) = panel.update_in(cx, |panel, window, cx| {
+                    panel.react(group.clone(), id, emoji.clone(), window, cx);
+                }) {
+                    log::warn!("nip29: sending a reaction failed: {error}");
+                }
+            }),
+        )
    })
 }

@@ -1,9 +1,10 @@
+use std::cmp::Reverse;
 use std::collections::{HashMap, HashSet};
 use std::sync::RwLock;

 use anyhow::{Error, anyhow};
-use common::EventExt;
-use gpui::{App, AppContext, Context, Entity, Global, Task};
+use common::{EventExt, emojis_from_tags};
+use gpui::{App, AppContext, Context, Entity, Global, Subscription, Task};
 use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
@@ -26,6 +27,7 @@ enum Dispatch {
    Person(Person),
    Announcement(Event),
    Relays(Event),
+    Emojis(Event),
 }

 /// Person Registry
@@ -33,15 +35,11 @@ enum Dispatch {
 pub struct PersonRegistry {
    /// Collection of all persons (user profiles)
    persons: HashMap<PublicKey, Entity<Person>>,
-
    /// Set of public keys that have been seen
    seen: RwLock<HashSet<PublicKey>>,
-
-    /// Sender for requesting metadata
    sender: flume::Sender<PublicKey>,
-
-    /// Tasks for asynchronous operations
    tasks: SmallVec<[Task<()>; 4]>,
+    _subscriptions: SmallVec<[Subscription; 1]>,
 }

 impl PersonRegistry {
@@ -57,9 +55,9 @@ impl PersonRegistry {

    /// Create a new person registry instance
    fn new(cx: &mut Context<Self>) -> Self {
-        let entity = cx.entity().downgrade();
        let nostr = NostrRegistry::global(cx);
        let client = nostr.read(cx).client();
+        let entity = cx.entity().downgrade();

        // Channel for communication between nostr and gpui
        let (tx, rx) = flume::bounded::<Dispatch>(100);
@@ -90,15 +88,27 @@ impl PersonRegistry {
                        Dispatch::Relays(event) => {
                            this.set_messaging_relays(&event, cx);
                        }
+                        Dispatch::Emojis(event) => {
+                            this.set_emojis(&event, cx);
+                        }
                    };
                })
                .ok();
            }
        }));

+        let subscription = cx.subscribe(&nostr, |this, _nostr, event, cx| {
+            if event.signer_changed() {
+                this.get_emojis(cx);
+            }
+        });
+
        // Load all user profiles from the database
        cx.defer(move |cx| {
-            entity.update(cx, |this, cx| this.load(cx)).ok();
+            _ = entity.update(cx, |this, cx| {
+                this.load(cx);
+                this.load_emojis(cx);
+            });
        });

        Self {
@@ -106,6 +116,7 @@ impl PersonRegistry {
            seen: RwLock::new(HashSet::new()),
            sender: metadata_tx,
            tasks,
+            _subscriptions: smallvec![subscription],
        }
    }

@@ -130,8 +141,9 @@ impl PersonRegistry {
                    Kind::Metadata => {
                        let metadata = Metadata::from_json(&event.content).unwrap_or_default();
                        let person = Person::new(event.pubkey, metadata);
+
                        if tx.send_async(Dispatch::Person(person)).await.is_err() {
-                            log::warn!("PersonRegistry channel closed, dropping metadata event");
+                            log::warn!("Channel closed, dropping metadata event");
                        }
                    }
                    Kind::ContactList => {
@@ -141,14 +153,15 @@ impl PersonRegistry {
                        }
                    }
                    Kind::InboxRelays => {
-                        tx.send_async(Dispatch::Relays(event.into_owned()))
-                            .await
-                            .ok();
+                        _ = tx.send_async(Dispatch::Relays(event.into_owned())).await;
+                    }
+                    Kind::Emojis => {
+                        _ = tx.send_async(Dispatch::Emojis(event.into_owned())).await;
                    }
                    Kind::Custom(10044) => {
-                        tx.send_async(Dispatch::Announcement(event.into_owned()))
-                            .await
-                            .ok();
+                        _ = tx
+                            .send_async(Dispatch::Announcement(event.into_owned()))
+                            .await;
                    }
                    _ => {}
                }
@@ -214,6 +227,61 @@ impl PersonRegistry {
        }));
    }

+    /// Load cached emoji lists from the database
+    fn load_emojis(&mut self, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+
+        type EmojiLists = Vec<(PublicKey, Vec<(String, Url)>)>;
+
+        let task: Task<Result<EmojiLists, Error>> = cx.background_spawn(async move {
+            let filter = Filter::new().kind(Kind::Emojis).limit(200);
+            let mut events: Vec<Event> =
+                client.database().query(filter).await?.into_iter().collect();
+
+            // Keep only the newest list per author
+            events.sort_by_key(|event| Reverse(event.created_at));
+            let mut seen = HashSet::new();
+
+            let lists = events
+                .into_iter()
+                .filter(|event| seen.insert(event.pubkey))
+                .map(|event| (event.pubkey, emojis_from_tags(&event.tags)))
+                .collect();
+
+            Ok(lists)
+        });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            if let Ok(lists) = task.await {
+                this.update(cx, |this, cx| {
+                    for (public_key, emojis) in lists {
+                        this.set_emojis_for(public_key, emojis, cx);
+                    }
+                })
+                .ok();
+            }
+        }));
+    }
+
+    /// Subscribe to the signed-in user's emoji list
+    fn get_emojis(&mut self, cx: &mut Context<Self>) {
+        let nostr = NostrRegistry::global(cx);
+        let client = nostr.read(cx).client();
+        let Some(public_key) = nostr.read(cx).current_user() else {
+            return;
+        };
+
+        self.tasks.push(cx.background_spawn(async move {
+            let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
+            let filter = Filter::new().kind(Kind::Emojis).author(public_key).limit(1);
+
+            if let Err(e) = client.subscribe(vec![filter]).close_on(opts).await {
+                log::warn!("Failed to subscribe to emoji list: {e}");
+            }
+        }));
+    }
+
    /// Set profile encryption keys announcement
    fn set_announcement(&mut self, event: &Event, cx: &mut App) {
        let Some(announcement) = Announcement::from_event(event) else {
@@ -248,6 +316,24 @@ impl PersonRegistry {
        }
    }

+    /// Set custom emoji for a person from their emoji list event
+    fn set_emojis(&mut self, event: &Event, cx: &mut App) {
+        self.set_emojis_for(event.pubkey, emojis_from_tags(&event.tags), cx);
+    }
+
+    /// Set custom emoji for a person
+    fn set_emojis_for(&mut self, public_key: PublicKey, emojis: Vec<(String, Url)>, cx: &mut App) {
+        if let Some(person) = self.persons.get(&public_key) {
+            person.update(cx, |person, cx| {
+                person.set_emojis(emojis);
+                cx.notify();
+            });
+        } else {
+            let person = Person::new(public_key, Metadata::default()).with_emojis(emojis);
+            self.insert(person, cx);
+        }
+    }
+
    /// Insert batch of persons
    fn bulk_insert(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
        for person in persons.into_iter() {
@@ -299,6 +385,29 @@ impl PersonRegistry {
        // Return a temporary profile with default metadata
        Person::new(public_key, Metadata::default())
    }
+
+    /// The signed-in user's custom emoji
+    pub fn current_emojis(cx: &App) -> Vec<(String, Url)> {
+        let registry = Self::global(cx);
+        let nostr = NostrRegistry::global(cx);
+
+        let Some(public_key) = nostr.read(cx).current_user() else {
+            return Vec::new();
+        };
+
+        registry.read(cx).get(&public_key, cx).emojis().to_vec()
+    }
+
+    /// An `emoji` tag for every signed-in user's custom emoji referenced.
+    pub fn emoji_tags(content: &str, cx: &App) -> Vec<Tag> {
+        let registry = Self::global(cx);
+        let nostr = NostrRegistry::global(cx);
+        let Some(public_key) = nostr.read(cx).current_user() else {
+            return Vec::new();
+        };
+
+        registry.read(cx).get(&public_key, cx).emoji_tags(content)
+    }
 }

 /// Get metadata for all public keys in a event
@@ -10,13 +10,12 @@ use state::Announcement;
 pub struct Person {
    /// Public Key
    public_key: PublicKey,
-
    /// Metadata (profile)
    metadata: Metadata,
-
+    /// Custom emoji (NIP-30) from the person's emoji list
+    emojis: Vec<(String, Url)>,
    /// Dekey (NIP-4e) announcement
    announcement: Option<Announcement>,
-
    /// Messaging relays
    messaging_relays: Vec<RelayUrl>,
 }
@@ -52,6 +51,7 @@ impl Person {
        Self {
            public_key,
            metadata,
+            emojis: vec![],
            announcement: None,
            messaging_relays: vec![],
        }
@@ -82,6 +82,36 @@ impl Person {
        self.metadata.clone()
    }

+    /// Custom emoji (NIP-30) as (shortcode, image url) pairs
+    pub fn emojis(&self) -> &[(String, Url)] {
+        &self.emojis
+    }
+
+    /// Set custom emoji from the person's emoji list
+    pub(crate) fn set_emojis(&mut self, emojis: Vec<(String, Url)>) {
+        self.emojis = emojis;
+    }
+
+    /// Build custom emoji from the person's emoji list
+    pub(crate) fn with_emojis(mut self, emojis: Vec<(String, Url)>) -> Self {
+        self.emojis = emojis;
+        self
+    }
+
+    /// An `emoji` tag for every custom emoji referenced as `:shortcode:` in `content`
+    pub fn emoji_tags(&self, content: &str) -> Vec<Tag> {
+        let mut tags = Vec::new();
+
+        for (shortcode, url) in &self.emojis {
+            let pattern = format!(":{shortcode}:");
+            if content.contains(&pattern) {
+                tags.push(Tag::custom("emoji", [shortcode.clone(), url.to_string()]));
+            }
+        }
+
+        tags
+    }
+
    /// Get profile encryption keys announcement
    pub fn announcement(&self) -> Option<Announcement> {
        self.announcement.clone()
@@ -1,8 +1,8 @@
 use std::ops::Range;

 use gpui::{
-    AnyElement, App, ElementId, HighlightStyle, IntoElement, SharedString, StyleRefinement,
-    Styled as _, Window,
+    AnyElement, App, ElementId, HighlightStyle, IntoElement, SharedString, SharedUri,
+    StyleRefinement, Styled as _, Window,
 };
 use gpui_base::{TextView, TextViewStyle};
 use theme::ActiveTheme as _;
@@ -12,6 +12,8 @@ use theme::ActiveTheme as _;
 pub struct InlineReplacement {
    pub range: Range<usize>,
    pub text: SharedString,
+    /// When set, the span renders as this image (NIP-30 custom emoji)
+    pub image: Option<SharedUri>,
 }

 impl InlineReplacement {
@@ -19,6 +21,19 @@ impl InlineReplacement {
        Self {
            range,
            text: text.into(),
+            image: None,
+        }
+    }
+
+    pub fn image(
+        range: Range<usize>,
+        alt: impl Into<SharedString>,
+        url: impl Into<SharedUri>,
+    ) -> Self {
+        Self {
+            range,
+            text: alt.into(),
+            image: Some(url.into()),
        }
    }
 }
@@ -46,11 +61,17 @@ impl RenderedText {
            }

            text.push_str(&content[last..range.start]);
-            text.push_str(&format!(
-                "[{}](<{}>)",
-                escape_link_text(&replacement.text),
-                &content[range.start..range.end]
-            ));
+            match &replacement.image {
+                Some(url) => text.push_str(&format!(
+                    "![{}](<{url}>)",
+                    escape_link_text(&replacement.text)
+                )),
+                None => text.push_str(&format!(
+                    "[{}](<{}>)",
+                    escape_link_text(&replacement.text),
+                    &content[range.start..range.end]
+                )),
+            }
            last = range.end;
        }
        text.push_str(&content[last..]);
@@ -370,26 +370,36 @@ impl RenderOnce for MessageMedia {
 /// Reactions of one emoji with the count of authors and whether the current user reacted.
 pub struct ReactionGroup {
    pub emoji: SharedString,
+    /// Image of a custom emoji (NIP-30) reaction
+    pub image: Option<SharedUri>,
    pub count: usize,
    pub mine: bool,
 }

-/// Group (emoji, author) pairs by emoji, sorted by emoji, marking groups containing `me`.
+/// Group (emoji, image, author) triples by emoji, sorted by emoji.
 pub fn group_reactions<A: PartialEq>(
-    reactions: impl IntoIterator<Item = (SharedString, A)>,
+    reactions: impl IntoIterator<Item = (SharedString, Option<SharedUri>, A)>,
    me: Option<A>,
 ) -> Vec<ReactionGroup> {
-    let mut groups: BTreeMap<SharedString, (usize, bool)> = BTreeMap::new();
+    let mut groups: BTreeMap<SharedString, (usize, bool, Option<SharedUri>)> = BTreeMap::new();

-    for (emoji, author) in reactions {
+    for (emoji, image, author) in reactions {
        let group = groups.entry(emoji).or_default();
        group.0 += 1;
        group.1 |= me.as_ref() == Some(&author);
+        if group.2.is_none() {
+            group.2 = image;
+        }
    }

    groups
        .into_iter()
-        .map(|(emoji, (count, mine))| ReactionGroup { emoji, count, mine })
+        .map(|(emoji, (count, mine, image))| ReactionGroup {
+            emoji,
+            image,
+            count,
+            mine,
+        })
        .collect()
 }

@@ -438,7 +448,10 @@ impl RenderOnce for ReactionBar {
                            .border_color(cx.theme().element_active)
                    })
                    .when(!group.mine, |this| this.border_color(cx.theme().border))
-                    .child(group.emoji)
+                    .when(group.image.is_none(), |this| this.child(group.emoji))
+                    .when_some(group.image, |this, image| {
+                        this.child(img(image).size(px(16.)).flex_shrink_0())
+                    })
                    .child(SharedString::from(group.count.to_string()))
            }))
    }