In case this doesn't work, I'll offer more detail on how to do it with busses. The more I think about it, the more I like the idea of preserving output -> input semantics anyway. Currently, when connecting more than one output to Client A's input, jack automatically adds the outputs and writes the result to A's buffer. This is now an input port, so its contents are only available to A. The lazy way to make the result of the add available to a meter, or any other clients, is to refrain from connecting the output ports to A's input and create a dummy jack client that just passes its input to its output. Connect the multiple output ports to the input of the dummy and connect the output of the dummy to the input of A. JACK automatically adds the multiple outputs as before, but this time it writes the result to a buffer that is an output port, so it is readable by all other clients. The dummy client is a perfect audio bus. I call this the lazy way because telling the user to use a client that does nothing, as a way of allowing the user to do something, is absurd. Also, if A's input is already connected to one output and the user wants to add another output to A's input, the user must first disconnect the first connection, then create the dummy, then connect the dummy's output to A's input, then connect all other outputs to the dummy's input. That's a lot of stuff for the user to do, indicating a lazy program. A more ambitious approach is to modify jack to create an input bus automatically whenever an input port is connected to more than one output port. First eliminate the ability for a client's input to be many-to-one. Every input port can now connect to only one output port. This might seem drastic but it's not, and it perfectly models the physical world (in the physical world, connecting two outputs to one input also connects their outputs to each other. Since output impedance is lower than input impedance, the signals flow from output to output with excessively high current and the input sees almost nothing. Using a bus to buffer the outputs is mandatory). This change is hidden from the user, who will still be allowed to connect as many outputs to A's input as he desires. The next change is to redefine how jack makes a many-to-one connection. When the user adds or deletes a connection to A's input port, jack checks to see if the new total number of connections is greater than 1. If so, jack inserts a bus, which is just a buffer, in front of A's input port and writes the sum of the outputs to this bus. The existence of this bus is hidden from the user (busses are always hidden internal mechanisms). Now any client can read from A's input port by reading from the bus output port. The state of the bus buffer with this technique is more stable than the state of A's buffer with the current technique, in that it changes only once per jack cycle while A's buffer currently changes twice per jack cycle. Tom