Salmention - IndieWeb
Jump to content
From IndieWeb
(Redirected from
Salmentions
Salmention icon
This article is a
stub
You can help the IndieWeb wiki by
expanding it
with
relevant
information.
Salmention
is a protocol extension to
Webmention
to
propagate comments
and other interactions upstream by sending a webmention from a response to the original post when the response itself receives a response (comment, like, etc.).
The original post then checks the response to the original, parses the response to the response (e.g. comment on a comment) and then displays it as an additional response on the original post.
Webmention with Salmention
depends on understanding
Webmention
. Please read that first.
The name is a portmanteau of
#Salmon
and
mention
Status
This is a
Living Specification
yet mature enough to encourage
implementations
and
feedback
Latest Published Version
Participate
issues
discussion on #indieweb-dev
on Libera IRC
Editors
Bebe Roberts
Tantek Çelik
Authors
Other contributors:
revision history
License
Per
CC0
, to the extent possible under law, the editor(s) and contributors have waived all copyright and related or neighboring rights to this work. In addition, as of 2026-04-24, the editor(s) and contributors (2015-04-07 onward) have made this specification available under the
Open Web Foundation Agreement Version 1.0
Summary
A Webmention is a notification that one URL links to another, usually a
comment
or other
response
. A Salmention is a special Webmention notification both that one URL links to another, and that one URL received and displayed the result of a Webmention itself. For example:
When Bob writes a reply on his website in response to a post on Alice's website, his site sends a webmention notifying her of his response, which her site's software can do with as it wishes, like display it as a comment on her post.
When Carol writes a reply on her site in response to Bob's comment, her site similarly sends a webmention to Bob … but what about Alice, who may wish to display this nested comment on her post?
This is where the Salmention extension comes in.
When Bob's post is updated to display Carol's reply, Bob's site
sends a webmention update (a salmention)
to Alice, even though Bob's post content itself hasn't changed. Alice's website software
looks for new information on Bob's post, which now includes Carol's response and displays it
as a nested response.
Salmention is a protocol between a salmention sender and a salmention receiver. In the example above:
The
salmention sender
is Bob’s site, it sends a webmention upstream whenever it itself displays the result of receiving a webmention.
The
salmention receiver
is Alice's site, when it receives the webmention update from Bob's site, it not only parses Bob's reply for any updates, but it also explicitly looks for responses to Bob's post, parses those, finds Carol's reply to Bob, and displays it as well.
Protocol
Sending Salmentions
An implementation that sends and receives
Webmentions
can send Salmentions by doing the following:
When it receives and accepts a Webmention from a response to an original post:
Incorporate (or update) the response into the original post’s permalink by nesting the response inside the original, keeping track of whether any changes actually occurred.
E.g. incorporate a
reply
as a nested comment
h-entry
inside the original’s
h-entry
If there were any changes (a new or updated response), then resend Webmentions to everything the original post sent webmentions to.
That act of resending those Webmentions when an original post is updated in response to responses is called “sending Salmentions”.
Receiving Salmentions
An implementation that receives
Webmentions
can receive Salmentions by doing the following:
When it receives a Webmention, in addition to normal Webmention processing:
Store the contents of the source of the Webmention in such a way that it can be rechecked in the future for any changes.
When it receives a previously received Webmention:
Check the source of the Webmention for any changes since the previous Webmention (using aforementioned stored contents), in particular any new responses to the source
E.g. check for new nested comment
h-entry
(s) inside the source’s
h-entry
Incorporate any new response(s) to the source both into those stored contents, and display as inline responses to the target itself.
E.g. displaying a reply to a reply, as an additional comment on the original post.
If the previous Webmention generated a
notification
, then the new response(s) should as well.
The act of noticing a re-receiving of a Webmention and doing something when there are changes in the source, specifically nested responses, is called “receiving Salmentions”.
IndieWeb Examples
In order of implementation
Aaron Parecki
Aaron Parecki
supports sending Salmentions since 2016-03-23, and receiving Salmentions on his site since 2015-07-12 and built this support to help pass
SWAT0
as Player B.
[1]
capjamesg
capjamesg
is building features to send and receive Salmentions in the
IndieWeb_Utils
library. Until the feature is complete, the code for Salmention functionality lives in a separate
capjamesg/salmention
GitHub repository.
Implementation Path
Here are the steps James has been using to implement Salmention:
1. Understand the algorithm.
2. Implement receiving Salmentions in Python, for use in his
SSG
3. Test the implementation and facilitate feedback. (NB: Salmentions are not as implemented as other IndieWeb specifications, so he is seeking guidance to ensure the spec is implemented correctly).
4. TODO: Write JavaScript code to facilitate displaying Salmentions on his personal website.
Previous Examples
Kyle Mahan
Kara Mahan
supported sending and receiving Salmentions on his site from 2015-06-09 until ~2019.
First mention sent:
kylewm.com/2015/06/i-have-to-go-to-bed-now-if-this-works-or-not-so-i
(2019 archive org link)
and received:
kylewm.com/2015/06/yeah-comment-threads-are-sort-of-a-todo-for-the-indieweb#kyle_mahan-4565
(2019 archive org link)
Ashton Macallan
Ashton McAllan
supported sending and receiving Salmentions on her site from 2015-06-13 to ~2021.
Receiving:
acegiak.net/2015/06/09/not-necessarily-threaded-comments-like-reddit-but-i-think-theres-broad-consensus-that-if-you-reply-to-a-reply-it-would-be/
(2021 archive org link)
Sending:
acegiak.net/2015/06/13/i-have-to-go-to-bed-now-if-this-works-or-not-so-i-hope-it-works/
(2021 archive org link)
Ben Roberts
Ben Roberts
supports sending Salmentions on his site since at least
2015-07-12
and built his support to help pass
SWAT0
as Player A. Support for receiving was added since then (date unsure) https://ben.thatmustbe.me/note/2016/5/16/2/ (needs archive org link)
Software Support
Known
Ben Werdmüller
added support for sending Salmentions on 2015-07-11
[2]
Possible issue: This reply to a Known post:
should have been Salmentioned up to the post that that Known post was in reply to:
, however that post itself does not display the downstream reply. So either:
Known is not sending a Salmention as it is expected to, and/or
aaronparecki.com is not receiving the Salmention and handling it (displaying it)
Previously: This was an example of a salmentioned comment received from a Known site:
kylewm.com/2016/05/nice-you-were-a-good-test-case-for-woodwind-there
(2019 archive org link)
Issues
This section is closed. Please add to
instead.
Awaiting original authors to move this issue to
Comment thread on separate page from post
This protocol requires that all replies be displayed on the same page as the post itself. I prefer to have the "conversation" on a second page, linked to from the post.
Idea: forward the webmention upstream instead of repeating the webmention from yourself. Then, upstream can parse the reply-to-reply, see that it is in reply to a comment in a conversation it manages, and add to the thread accordingly. No display of the replies on the intermediate site is required at all for this flow.
Related
ActivityPub
Main article:
ActivityPub
ActivityPub
describes a similar process to Salmention for propagating updates between systems. If one of your posts receives a mention (eg. as the target of a like, repost or inReplyTo, etc), your server should send the
new post
(the one that mentions you) to
all recipients
of your original post. (In ActivityPub, your server pushes your posts out to your followers, and retains a list of everyone posts are sent to, but this basically translates to sending a webmention to the original post).
Salmon
Main article:
Salmon
The
Salmon
protocol is a predecessor to
#ActivityPub
that broke useful conceptual ground but never gained widespread adoption. It's part of the
OStatus
protocol suite.
See Also
comment-propagation
reply-chain
Silo example: Twitter experiment showing when the author of a tweet likes replies to that tweet, which since they are second-order responses, are a visualization of salmentions though in a silo context:
Retrieved from "
Category
stubs