Merge branch 'develop' into marchcat/xcode-16

author: Nat Goodspeed <nat@lindenlab.com> 2024-10-22 14:46:15 -0400
committer: Nat Goodspeed <nat@lindenlab.com> 2024-10-22 14:46:15 -0400
commit: bfe759584f63c0587a2dc6a0086ad9d5b6c63a56 (patch)
tree: 84653a1211908c7dd2ce5bc4877e79f8e6515099 /indra
parent: 62fc3ceaf5251458239f91192a05edc64bedf33b (diff)
parent: 394f7b37f2ec05c7cfb32c350432886f1c493c85 (diff)
162 files changed, 5047 insertions, 1133 deletions
diff --git a/indra/cmake/Python.cmake b/indra/cmake/Python.cmake
index da5d2ef22c..39fd21c33f 100644
--- a/indra/cmake/Python.cmake
+++ b/indra/cmake/Python.cmake
@@ -13,7 +13,7 @@ elseif (WINDOWS)
   foreach(hive HKEY_CURRENT_USER HKEY_LOCAL_MACHINE)
     # prefer more recent Python versions to older ones, if multiple versions
     # are installed
-    foreach(pyver 3.12 3.11 3.10 3.9 3.8 3.7)
+    foreach(pyver 3.14 3.13 3.12 3.11 3.10 3.9 3.8 3.7)
       list(APPEND regpaths "[${hive}\\SOFTWARE\\Python\\PythonCore\\${pyver}\\InstallPath]")
     endforeach()
   endforeach()
diff --git a/indra/cmake/UI.cmake b/indra/cmake/UI.cmake
index ae039b4a47..595f394af4 100644
--- a/indra/cmake/UI.cmake
+++ b/indra/cmake/UI.cmake
@@ -6,15 +6,22 @@ include(GLIB)
 add_library( ll::uilibraries INTERFACE IMPORTED )
 
 if (LINUX)
-  use_prebuilt_binary(fltk)
-  target_compile_definitions(ll::uilibraries INTERFACE LL_FLTK=1 LL_X11=1 )
+  target_compile_definitions(ll::uilibraries INTERFACE LL_X11=1 )
 
   if( USE_CONAN )
     return()
   endif()
 
+  include(FindPkgConfig)
+  pkg_check_modules(WAYLAND_CLIENT wayland-client)
+
+  if( WAYLAND_CLIENT_FOUND )
+      target_compile_definitions( ll::uilibraries INTERFACE LL_WAYLAND=1)
+  else()
+      message("pkgconfig could not find wayland client, compiling without full wayland support")
+  endif()
+
   target_link_libraries( ll::uilibraries INTERFACE
-          fltk
           Xrender
           Xcursor
           Xfixes
diff --git a/indra/llcommon/coro_scheduler.cpp b/indra/llcommon/coro_scheduler.cpp
index 2d8b6e1a97..b6117fa6a1 100644
--- a/indra/llcommon/coro_scheduler.cpp
+++ b/indra/llcommon/coro_scheduler.cpp
@@ -20,6 +20,7 @@
 #include <boost/fiber/operations.hpp>
 // other Linden headers
 #include "llcallbacklist.h"
+#include "llcoros.h"
 #include "lldate.h"
 #include "llerror.h"
 
@@ -56,17 +57,55 @@ void scheduler::awakened( boost::fibers::context* ctx) noexcept
 
 boost::fibers::context* scheduler::pick_next() noexcept
 {
+    auto now = LLDate::now().secondsSinceEpoch();
     // count calls to pick_next()
     ++mSwitches;
     // pick_next() is called when the previous fiber has suspended, and we
     // need to pick another. Did the previous pick_next() call pick the main
-    // fiber? If so, it's the main fiber that just suspended.
-    auto now = LLDate::now().secondsSinceEpoch();
-    if (mMainRunning)
+    // fiber? (Or is this the first pick_next() call?) If so, it's the main
+    // fiber that just suspended.
+    if ((! mPrevCtx) || mPrevCtx->get_id() == mMainID)
     {
-        mMainRunning = false;
         mMainLast = now;
     }
+    else
+    {
+        // How long did we spend in the fiber that just suspended?
+        // Don't bother with long runs of the main fiber, since (a) it happens
+        // pretty often and (b) it's moderately likely that we've reached here
+        // from the canonical yield at the top of mainloop, and what we'd want
+        // to know about is whatever the main fiber was doing in the
+        // *previous* iteration of mainloop.
+        F64 elapsed{ now - mResumeTime };
+        LLCoros::CoroData& data{ LLCoros::get_CoroData(mPrevCtx->get_id()) };
+        // Find iterator to the first mHistogram key greater than elapsed.
+        auto past = data.mHistogram.upper_bound(elapsed);
+        // If the smallest key (mHistogram.begin()->first) is greater than
+        // elapsed, then we need not bother with this timeslice.
+        if (past != data.mHistogram.begin())
+        {
+            // Here elapsed was greater than at least one key. Back off to the
+            // previous entry and increment that count. If it's end(), backing
+            // off gets us the last entry -- assuming mHistogram isn't empty.
+            llassert(! data.mHistogram.empty());
+            ++(--past)->second;
+            LL::WorkQueue::ptr_t queue{ getWorkQueue() };
+            // make sure the queue exists
+            if (queue)
+            {
+                // If it proves difficult to track down *why* the fiber spent so
+                // much time, consider also binding and reporting
+                // boost::stacktrace::stacktrace().
+                queue->post(
+                    [name=data.getName(), elapsed]
+                    {
+                        LL_WARNS_ONCE("LLCoros.scheduler")
+                            << "Coroutine " << name << " ran for "
+                            << elapsed << " seconds" << LL_ENDL;
+                    });
+            }
+        }
+    }
 
     boost::fibers::context* next;
 
@@ -96,17 +135,9 @@ boost::fibers::context* scheduler::pick_next() noexcept
         // passage could be skipped.
 
         // Record this event for logging, but push it off to a thread pool to
-        // perform that work. Presumably std::weak_ptr::lock() is cheaper than
-        // WorkQueue::getInstance().
-        LL::WorkQueue::ptr_t queue{ mQueue.lock() };
-        // We probably started before the relevant WorkQueue was created.
-        if (! queue)
-        {
-            // Try again to locate the specified WorkQueue.
-            queue = LL::WorkQueue::getInstance(qname);
-            mQueue = queue;
-        }
-        // Both the lock() call and the getInstance() call might have failed.
+        // perform that work.
+        LL::WorkQueue::ptr_t queue{ getWorkQueue() };
+        // The work queue we're looking for might not exist right now.
         if (queue)
         {
             // Bind values. Do NOT bind 'this' to avoid cross-thread access!
@@ -116,7 +147,6 @@ boost::fibers::context* scheduler::pick_next() noexcept
             // so we have no access.
             queue->post(
                 [switches=mSwitches, start=mStart, elapsed, now]
-                ()
                 {
                     U32 runtime(U32(now) - U32(start));
                     U32 minutes(runtime / 60u);
@@ -150,12 +180,29 @@ boost::fibers::context* scheduler::pick_next() noexcept
     {
         // we're about to resume the main fiber: it's no longer "ready"
         mMainCtx = nullptr;
-        // instead, it's "running"
-        mMainRunning = true;
     }
+    mPrevCtx = next;
+    // remember when we resumed this fiber so our next call can measure how
+    // long the previous resumption was
+    mResumeTime = LLDate::now().secondsSinceEpoch();
     return next;
 }
 
+LL::WorkQueue::ptr_t scheduler::getWorkQueue()
+{
+    // Cache a weak_ptr to our target work queue, presuming that
+    // std::weak_ptr::lock() is cheaper than WorkQueue::getInstance().
+    LL::WorkQueue::ptr_t queue{ mQueue.lock() };
+    // We probably started before the relevant WorkQueue was created.
+    if (! queue)
+    {
+        // Try again to locate the specified WorkQueue.
+        queue = LL::WorkQueue::getInstance(qname);
+        mQueue = queue;
+    }
+    return queue;
+}
+
 void scheduler::use()
 {
     boost::fibers::use_scheduling_algorithm<scheduler>();
diff --git a/indra/llcommon/coro_scheduler.h b/indra/llcommon/coro_scheduler.h
index eee2d746b5..7af90685dc 100644
--- a/indra/llcommon/coro_scheduler.h
+++ b/indra/llcommon/coro_scheduler.h
@@ -47,17 +47,20 @@ public:
     static void use();
 
 private:
-    // This is the fiber::id of the main fiber. We use this to discover
-    // whether the fiber passed to awakened() is in fact the main fiber.
+    LL::WorkQueue::ptr_t getWorkQueue();
+
+    // This is the fiber::id of the main fiber.
     boost::fibers::fiber::id mMainID;
-    // This context* is nullptr until awakened() notices that the main fiber
-    // has become ready, at which point it contains the main fiber's context*.
+    // This context* is nullptr while the main fiber is running or suspended,
+    // but is set to the main fiber's context each time the main fiber is ready.
     boost::fibers::context* mMainCtx{};
-    // Set when pick_next() returns the main fiber.
-    bool mMainRunning{ false };
+    // Remember the context returned by the previous pick_next() call.
+    boost::fibers::context* mPrevCtx{};
     // If it's been at least this long since the last time the main fiber got
     // control, jump it to the head of the queue.
     F64 mTimeslice{ DEFAULT_TIMESLICE };
+    // Time when we resumed the most recently running fiber
+    F64 mResumeTime{ 0 };
     // Timestamp as of the last time we suspended the main fiber.
     F64 mMainLast{ 0 };
     // Timestamp of start time
diff --git a/indra/llcommon/indra_constants.h b/indra/llcommon/indra_constants.h
index 566ea2ea14..a0394da281 100644
--- a/indra/llcommon/indra_constants.h
+++ b/indra/llcommon/indra_constants.h
@@ -355,5 +355,7 @@ constexpr U8 CLICK_ACTION_DISABLED = 8;
 constexpr U8 CLICK_ACTION_IGNORE = 9;
 // DO NOT CHANGE THE SEQUENCE OF THIS LIST!!
 
+constexpr U32 BEACON_SHOW_MAP  = 0x0001;
+constexpr U32 BEACON_FOCUS_MAP = 0x0002;
 
 #endif
diff --git a/indra/llcommon/llcoros.cpp b/indra/llcommon/llcoros.cpp
index 1ae5c87a00..5a3cbd2ef1 100644
--- a/indra/llcommon/llcoros.cpp
+++ b/indra/llcommon/llcoros.cpp
@@ -57,16 +57,19 @@
 #include "llsdutil.h"
 #include "lltimer.h"
 #include "stringize.h"
+#include "scope_exit.h"
 
 #if LL_WINDOWS
 #include <excpt.h>
 #endif
 
+thread_local std::unordered_map<std::string, int> LLCoros::mPrefixMap;
+thread_local std::unordered_map<std::string, LLCoros::id> LLCoros::mNameMap;
+
 // static
 bool LLCoros::on_main_coro()
 {
-    return (!LLCoros::instanceExists() ||
-            LLCoros::getName().empty());
+    return (!instanceExists() || get_CoroData().isMain);
 }
 
 // static
@@ -76,11 +79,11 @@ bool LLCoros::on_main_thread_main_coro()
 }
 
 // static
-LLCoros::CoroData& LLCoros::get_CoroData(const std::string&)
+LLCoros::CoroData& LLCoros::get_CoroData()
 {
     CoroData* current{ nullptr };
     // be careful about attempted accesses in the final throes of app shutdown
-    if (! wasDeleted())
+    if (instanceExists())
     {
         current = instance().mCurrent.get();
     }
@@ -89,16 +92,26 @@ LLCoros::CoroData& LLCoros::get_CoroData(const std::string&)
     // canonical values.
     if (! current)
     {
-        static std::atomic<int> which_thread(0);
-        // Use alternate CoroData constructor.
-        static thread_local CoroData sMain(which_thread++);
         // We need not reset() the local_ptr to this instance; we'll simply
         // find it again every time we discover that current is null.
-        current = &sMain;
+        current = &main_CoroData();
     }
     return *current;
 }
 
+LLCoros::CoroData& LLCoros::get_CoroData(id id)
+{
+    auto found = CoroData::getInstance(id);
+    return found? *found : main_CoroData();
+}
+
+LLCoros::CoroData& LLCoros::main_CoroData()
+{
+    // tell CoroData we're "main"
+    static thread_local CoroData sMain("");
+    return sMain;
+}
+
 //static
 LLCoros::coro::id LLCoros::get_self()
 {
@@ -108,28 +121,28 @@ LLCoros::coro::id LLCoros::get_self()
 //static
 void LLCoros::set_consuming(bool consuming)
 {
-    auto& data(get_CoroData("set_consuming()"));
+    auto& data(get_CoroData());
     // DO NOT call this on the main() coroutine.
-    llassert_always(! data.mName.empty());
+    llassert_always(! data.isMain);
     data.mConsuming = consuming;
 }
 
 //static
 bool LLCoros::get_consuming()
 {
-    return get_CoroData("get_consuming()").mConsuming;
+    return get_CoroData().mConsuming;
 }
 
 // static
 void LLCoros::setStatus(const std::string& status)
 {
-    get_CoroData("setStatus()").mStatus = status;
+    get_CoroData().mStatus = status;
 }
 
 // static
 std::string LLCoros::getStatus()
 {
-    return get_CoroData("getStatus()").mStatus;
+    return get_CoroData().mStatus;
 }
 
 LLCoros::LLCoros():
@@ -186,9 +199,8 @@ void LLCoros::cleanupSingleton()
 
 std::string LLCoros::generateDistinctName(const std::string& prefix) const
 {
-    static int unique = 0;
-
-    // Allowing empty name would make getName()'s not-found return ambiguous.
+    // Empty name would trigger CoroData's constructor's special case for the
+    // main coroutine.
     if (prefix.empty())
     {
         LL_ERRS("LLCoros") << "LLCoros::launch(): pass non-empty name string" << LL_ENDL;
@@ -196,9 +208,11 @@ std::string LLCoros::generateDistinctName(const std::string& prefix) const
 
     // If the specified name isn't already in the map, just use that.
     std::string name(prefix);
+    // maintain a distinct int suffix for each prefix
+    int& unique = mPrefixMap[prefix];
 
-    // Until we find an unused name, append a numeric suffix for uniqueness.
-    while (CoroData::getInstance(name))
+    // Until we find an unused name, append int suffix for uniqueness.
+    while (mNameMap.find(name) != mNameMap.end())
     {
         name = stringize(prefix, unique++);
     }
@@ -207,9 +221,16 @@ std::string LLCoros::generateDistinctName(const std::string& prefix) const
 
 bool LLCoros::killreq(const std::string& name)
 {
-    auto found = CoroData::getInstance(name);
+    auto foundName = mNameMap.find(name);
+    if (foundName == mNameMap.end())
+    {
+        // couldn't find that name in map
+        return false;
+    }
+    auto found = CoroData::getInstance(foundName->second);
     if (! found)
     {
+        // found name, but CoroData with that ID key no longer exists
         return false;
     }
     // Next time the subject coroutine calls checkStop(), make it terminate.
@@ -224,14 +245,13 @@ bool LLCoros::killreq(const std::string& name)
 //static
 std::string LLCoros::getName()
 {
-    return get_CoroData("getName()").mName;
+    return get_CoroData().getName();
 }
 
-//static
-std::string LLCoros::logname()
+// static
+std::string LLCoros::getName(id id)
 {
-    auto& data(get_CoroData("logname()"));
-    return data.mName.empty()? data.getKey() : data.mName;
+    return get_CoroData(id).getName();
 }
 
 void LLCoros::saveException(const std::string& name, std::exception_ptr exc)
@@ -264,7 +284,7 @@ void LLCoros::printActiveCoroutines(const std::string& when)
     {
         LL_INFOS("LLCoros") << "-------------- List of active coroutines ------------";
         F64 time = LLTimer::getTotalSeconds();
-        for (auto& cd : CoroData::instance_snapshot())
+        for (const auto& cd : CoroData::instance_snapshot())
         {
             F64 life_time = time - cd.mCreationTime;
             LL_CONT << LL_NEWLINE
@@ -323,6 +343,33 @@ void LLCoros::toplevel(std::string name, callable_t callable)
     // run the code the caller actually wants in the coroutine
     try
     {
+        LL::scope_exit report{
+            [&corodata]
+            {
+                bool allzero = true;
+                for (const auto& [threshold, occurs] : corodata.mHistogram)
+                {
+                    if (occurs)
+                    {
+                        allzero = false;
+                        break;
+                    }
+                }
+                if (! allzero)
+                {
+                    LL_WARNS("LLCoros") << "coroutine " << corodata.mName;
+                    const char* sep = " exceeded ";
+                    for (const auto& [threshold, occurs] : corodata.mHistogram)
+                    {
+                        if (occurs)
+                        {
+                            LL_CONT << sep << threshold << " " << occurs << " times";
+                            sep = ", ";
+                        }
+                    }
+                    LL_ENDL;
+                }
+            }};
         LL::seh::catcher(callable);
     }
     catch (const Stop& exc)
@@ -364,8 +411,8 @@ void LLCoros::checkStop(callable_t cleanup)
 
     // do this AFTER the check above, because get_CoroData() depends on the
     // local_ptr in our instance().
-    auto& data(get_CoroData("checkStop()"));
-    if (data.mName.empty())
+    auto& data(get_CoroData());
+    if (data.isMain)
     {
         // Our Stop exception and its subclasses are intended to stop loitering
         // coroutines. Don't throw it from the main coroutine.
@@ -385,7 +432,7 @@ void LLCoros::checkStop(callable_t cleanup)
     {
         // Someone wants to kill this coroutine
         cleanup();
-        LLTHROW(Killed(stringize("coroutine ", data.mName, " killed by ", data.mKilledBy)));
+        LLTHROW(Killed(stringize("coroutine ", data.getName(), " killed by ", data.mKilledBy)));
     }
 }
 
@@ -445,20 +492,51 @@ LLBoundListener LLCoros::getStopListener(const std::string& caller,
 }
 
 LLCoros::CoroData::CoroData(const std::string& name):
-    LLInstanceTracker<CoroData, std::string>(name),
+    super(boost::this_fiber::get_id()),
     mName(name),
-    mCreationTime(LLTimer::getTotalSeconds())
+    mCreationTime(LLTimer::getTotalSeconds()),
+    // Preset threshold times in mHistogram
+    mHistogram{
+        {0.004, 0},
+        {0.040, 0},
+        {0.400, 0},
+        {1.000, 0}
+    }
 {
+    // we expect the empty string for the main coroutine
+    if (name.empty())
+    {
+        isMain = true;
+        if (on_main_thread())
+        {
+            // main coroutine on main thread
+            mName = "main";
+        }
+        else
+        {
+            // main coroutine on some other thread
+            static std::atomic<int> main_no{ 0 };
+            mName = stringize("main", ++main_no);
+        }
+    }
+    // maintain LLCoros::mNameMap
+    LLCoros::mNameMap.emplace(mName, getKey());
+}
+
+LLCoros::CoroData::~CoroData()
+{
+    // Don't try to erase the static main CoroData from our static
+    // thread_local mNameMap; that could run into destruction order problems.
+    if (! isMain)
+    {
+        LLCoros::mNameMap.erase(mName);
+    }
 }
 
-LLCoros::CoroData::CoroData(int n):
-    // This constructor is used for the thread_local instance belonging to the
-    // default coroutine on each thread. We must give each one a different
-    // LLInstanceTracker key because LLInstanceTracker's map spans all
-    // threads, but we want the default coroutine on each thread to have the
-    // empty string as its visible name because some consumers test for that.
-    LLInstanceTracker<CoroData, std::string>("main" + stringize(n)),
-    mName(),
-    mCreationTime(LLTimer::getTotalSeconds())
+std::string LLCoros::CoroData::getName() const
 {
+    if (mStatus.empty())
+        return mName;
+    else
+        return stringize(mName, " (", mStatus, ")");
 }
diff --git a/indra/llcommon/llcoros.h b/indra/llcommon/llcoros.h
index 0291d7f1d9..1edcb7e387 100644
--- a/indra/llcommon/llcoros.h
+++ b/indra/llcommon/llcoros.h
@@ -37,41 +37,38 @@
 #include <boost/fiber/fss.hpp>
 #include <exception>
 #include <functional>
+#include <map>
 #include <queue>
 #include <string>
+#include <unordered_map>
+
+namespace llcoro
+{
+class scheduler;
+}
 
 /**
- * Registry of named Boost.Coroutine instances
- *
- * The Boost.Coroutine library supports the general case of a coroutine
- * accepting arbitrary parameters and yielding multiple (sets of) results. For
- * such use cases, it's natural for the invoking code to retain the coroutine
- * instance: the consumer repeatedly calls into the coroutine, perhaps passing
- * new parameter values, prompting it to yield its next result.
- *
- * Our typical coroutine usage is different, though. For us, coroutines
- * provide an alternative to the @c Responder pattern. Our typical coroutine
- * has @c void return, invoked in fire-and-forget mode: the handler for some
- * user gesture launches the coroutine and promptly returns to the main loop.
- * The coroutine initiates some action that will take multiple frames (e.g. a
- * capability request), waits for its result, processes it and silently steals
- * away.
+ * Registry of named Boost.Fiber instances
  *
- * This usage poses two (related) problems:
+ * When the viewer first introduced the semi-independent execution agents now
+ * called fibers, the term "fiber" had not yet become current, and the only
+ * available libraries used the term "coroutine" instead. Within the viewer we
+ * continue to use the term "coroutines," though at present they are actually
+ * boost::fibers::fiber instances.
  *
- * # Who should own the coroutine instance? If it's simply local to the
- *   handler code that launches it, return from the handler will destroy the
- *   coroutine object, terminating the coroutine.
- * # Once the coroutine terminates, in whatever way, who's responsible for
- *   cleaning up the coroutine object?
+ * Coroutines provide an alternative to the @c Responder pattern. Our typical
+ * coroutine has @c void return, invoked in fire-and-forget mode: the handler
+ * for some user gesture launches the coroutine and promptly returns to the
+ * main loop. The coroutine initiates some action that will take multiple
+ * frames (e.g. a capability request), waits for its result, processes it and
+ * silently steals away.
  *
  * LLCoros is a Singleton collection of currently-active coroutine instances.
  * Each has a name. You ask LLCoros to launch a new coroutine with a suggested
  * name prefix; from your prefix it generates a distinct name, registers the
  * new coroutine and returns the actual name.
  *
- * The name
- * can provide diagnostic info: we can look up the name of the
+ * The name can provide diagnostic info: we can look up the name of the
  * currently-running coroutine.
  */
 class LL_COMMON_API LLCoros: public LLSingleton<LLCoros>
@@ -91,12 +88,8 @@ public:
     // llassert(LLCoros::on_main_thread_main_coro())
     static bool on_main_thread_main_coro();
 
-    /// The viewer's use of the term "coroutine" became deeply embedded before
-    /// the industry term "fiber" emerged to distinguish userland threads from
-    /// simpler, more transient kinds of coroutines. Semantically they've
-    /// always been fibers. But at this point in history, we're pretty much
-    /// stuck with the term "coroutine."
     typedef boost::fibers::fiber coro;
+    typedef coro::id id;
     /// Canonical callable type
     typedef std::function<void()> callable_t;
 
@@ -150,13 +143,16 @@ public:
 
     /**
      * From within a coroutine, look up the (tweaked) name string by which
-     * this coroutine is registered. Returns the empty string if not found
-     * (e.g. if the coroutine was launched by hand rather than using
-     * LLCoros::launch()).
+     * this coroutine is registered.
      */
     static std::string getName();
 
     /**
+     * Given an id, return the name of that coroutine.
+     */
+    static std::string getName(id);
+
+    /**
      * rethrow() is called by the thread's main fiber to propagate an
      * exception from any coroutine into the main fiber, where it can engage
      * the normal unhandled-exception machinery, up to and including crash
@@ -170,13 +166,6 @@ public:
     void rethrow();
 
     /**
-     * This variation returns a name suitable for log messages: the explicit
-     * name for an explicitly-launched coroutine, or "mainN" for the default
-     * coroutine on a thread.
-     */
-    static std::string logname();
-
-    /**
      * For delayed initialization. To be clear, this will only affect
      * coroutines launched @em after this point. The underlying facility
      * provides no way to alter the stack size of any running coroutine.
@@ -187,7 +176,7 @@ public:
     void printActiveCoroutines(const std::string& when=std::string());
 
     /// get the current coro::id for those who really really care
-    static coro::id get_self();
+    static id get_self();
 
     /**
      * Most coroutines, most of the time, don't "consume" the events for which
@@ -236,6 +225,7 @@ public:
             setStatus(status);
         }
         TempStatus(const TempStatus&) = delete;
+        TempStatus& operator=(const TempStatus&) = delete;
         ~TempStatus()
         {
             setStatus(mOldStatus);
@@ -331,10 +321,14 @@ public:
     using local_ptr = boost::fibers::fiber_specific_ptr<T>;
 
 private:
+    friend class llcoro::scheduler;
+
     std::string generateDistinctName(const std::string& prefix) const;
     void toplevel(std::string name, callable_t callable);
     struct CoroData;
-    static CoroData& get_CoroData(const std::string& caller);
+    static CoroData& get_CoroData();
+    static CoroData& get_CoroData(id);
+    static CoroData& main_CoroData();
     void saveException(const std::string& name, std::exception_ptr exc);
 
     LLTempBoundListener mConn;
@@ -355,13 +349,18 @@ private:
     S32 mStackSize;
 
     // coroutine-local storage, as it were: one per coro we track
-    struct CoroData: public LLInstanceTracker<CoroData, std::string>
+    struct CoroData: public LLInstanceTracker<CoroData, id>
     {
+        using super = LLInstanceTracker<CoroData, id>;
+
         CoroData(const std::string& name);
-        CoroData(int n);
+        ~CoroData();
 
+        std::string getName() const;
+
+        bool isMain{ false };
         // tweaked name of the current coroutine
-        const std::string mName;
+        std::string mName;
         // set_consuming() state -- don't consume events unless specifically directed
         bool mConsuming{ false };
         // killed by which coroutine
@@ -369,20 +368,24 @@ private:
         // setStatus() state
         std::string mStatus;
         F64 mCreationTime; // since epoch
+        // Histogram of how many times this coroutine's timeslice exceeds
+        // certain thresholds. mHistogram is pre-populated with those
+        // thresholds as keys. If k0 is one threshold key and k1 is the next,
+        // mHistogram[k0] is the number of times a coroutine timeslice tn ran
+        // (k0 <= tn < k1). A timeslice less than mHistogram.begin()->first is
+        // fine; we don't need to record those.
+        std::map<F64, U32> mHistogram;
     };
 
     // Identify the current coroutine's CoroData. This local_ptr isn't static
     // because it's a member of an LLSingleton, and we rely on it being
     // cleaned up in proper dependency order.
     local_ptr<CoroData> mCurrent;
-};
 
-namespace llcoro
-{
-
-inline
-std::string logname() { return LLCoros::logname(); }
-
-} // llcoro
+    // ensure name uniqueness
+    static thread_local std::unordered_map<std::string, int> mPrefixMap;
+    // lookup by name
+    static thread_local std::unordered_map<std::string, id> mNameMap;
+};
 
 #endif /* ! defined(LL_LLCOROS_H) */
diff --git a/indra/llcommon/workqueue.cpp b/indra/llcommon/workqueue.cpp
index 9138c862f9..8b7b97a1f9 100644
--- a/indra/llcommon/workqueue.cpp
+++ b/indra/llcommon/workqueue.cpp
@@ -127,9 +127,7 @@ void LL::WorkQueueBase::error(const std::string& msg)
 
 void LL::WorkQueueBase::checkCoroutine(const std::string& method)
 {
-    // By convention, the default coroutine on each thread has an empty name
-    // string. See also LLCoros::logname().
-    if (LLCoros::getName().empty())
+    if (LLCoros::on_main_coro())
     {
         LLTHROW(Error("Do not call " + method + " from a thread's default coroutine"));
     }
diff --git a/indra/llinventory/llsettingssky.cpp b/indra/llinventory/llsettingssky.cpp
index 3685915ffd..ce6244d038 100644
--- a/indra/llinventory/llsettingssky.cpp
+++ b/indra/llinventory/llsettingssky.cpp
@@ -1995,6 +1995,7 @@ F32 LLSettingsSky::getCloudShadow() const
 void LLSettingsSky::setCloudShadow(F32 val)
 {
     mCloudShadow = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2051,6 +2052,7 @@ F32 LLSettingsSky::getMaxY() const
 void LLSettingsSky::setMaxY(F32 val)
 {
     mMaxY = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2062,6 +2064,7 @@ LLQuaternion LLSettingsSky::getMoonRotation() const
 void LLSettingsSky::setMoonRotation(const LLQuaternion &val)
 {
     mMoonRotation = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2073,6 +2076,7 @@ F32 LLSettingsSky::getMoonScale() const
 void LLSettingsSky::setMoonScale(F32 val)
 {
     mMoonScale = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2095,6 +2099,7 @@ F32 LLSettingsSky::getMoonBrightness() const
 void LLSettingsSky::setMoonBrightness(F32 brightness_factor)
 {
     mMoonBrightness = brightness_factor;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2131,6 +2136,7 @@ LLColor3 LLSettingsSky::getSunlightColorClamped() const
 void LLSettingsSky::setSunlightColor(const LLColor3 &val)
 {
     mSunlightColor = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2142,6 +2148,7 @@ LLQuaternion LLSettingsSky::getSunRotation() const
 void LLSettingsSky::setSunRotation(const LLQuaternion &val)
 {
     mSunRotation = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
@@ -2153,6 +2160,7 @@ F32 LLSettingsSky::getSunScale() const
 void LLSettingsSky::setSunScale(F32 val)
 {
     mSunScale = val;
+    setDirtyFlag(true);
     setLLSDDirty();
 }
 
diff --git a/indra/llmessage/llcoproceduremanager.cpp b/indra/llmessage/llcoproceduremanager.cpp
index 13972ad399..5539ca7b86 100644
--- a/indra/llmessage/llcoproceduremanager.cpp
+++ b/indra/llmessage/llcoproceduremanager.cpp
@@ -403,6 +403,7 @@ void LLCoprocedurePool::coprocedureInvokerCoro(
     CoprocQueuePtr pendingCoprocs,
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter)
 {
+    std::string prevtask;
     for (;;)
     {
         // It is VERY IMPORTANT that we instantiate a new ptr_t just before
@@ -424,10 +425,25 @@ void LLCoprocedurePool::coprocedureInvokerCoro(
         // destroyed during pop_wait_for().
         QueuedCoproc::ptr_t coproc;
         boost::fibers::channel_op_status status;
+        // Each time control reaches our custom coroutine scheduler, we check
+        // how long the previous coroutine ran before yielding, and report
+        // coroutines longer than a certain cutoff. But these coprocedure pool
+        // coroutines are generic; the only way we know what work they're
+        // doing is the task 'status' set by LLCoros::setStatus(). But what if
+        // the coroutine runs the task to completion and returns to waiting?
+        // It does no good to report that "waiting" ran long. So each time we
+        // enter "waiting" status, also report the *previous* task name.
+        std::string waiting = "waiting", newstatus;
+        if (prevtask.empty())
         {
-            LLCoros::TempStatus st("waiting for work for 10s");
-            status = pendingCoprocs->pop_wait_for(coproc, std::chrono::seconds(10));
+            newstatus = waiting;
         }
+        else
+        {
+            newstatus = stringize("done ", prevtask, "; ", waiting);
+        }
+        LLCoros::setStatus(newstatus);
+        status = pendingCoprocs->pop_wait_for(coproc, std::chrono::seconds(10));
         if (status == boost::fibers::channel_op_status::closed)
         {
             break;
@@ -436,6 +452,7 @@ void LLCoprocedurePool::coprocedureInvokerCoro(
         if(status == boost::fibers::channel_op_status::timeout)
         {
             LL_DEBUGS_ONCE("CoProcMgr") << "pool '" << mPoolName << "' waiting." << LL_ENDL;
+            prevtask.clear();
             continue;
         }
         // we actually popped an item
@@ -446,6 +463,9 @@ void LLCoprocedurePool::coprocedureInvokerCoro(
 
         try
         {
+            // set "status" of pool coroutine to the name of the coproc task
+            prevtask = coproc->mName;
+            LLCoros::setStatus(prevtask);
             coproc->mProc(httpAdapter, coproc->mId);
         }
         catch (const LLCoros::Stop &e)
diff --git a/indra/llmessage/llexperiencecache.cpp b/indra/llmessage/llexperiencecache.cpp
index b5d0c93376..ea9475ed69 100644
--- a/indra/llmessage/llexperiencecache.cpp
+++ b/indra/llmessage/llexperiencecache.cpp
@@ -110,9 +110,8 @@ void LLExperienceCache::initSingleton()
 
     LLCoprocedureManager::instance().initializePool("ExpCache");
 
-    LLCoros::instance().launch("LLExperienceCache::idleCoro",
-        boost::bind(&LLExperienceCache::idleCoro, this));
-
+    const F32 SECS_BETWEEN_REQUESTS = 0.5f;
+    mExpirationTimerHandle = LL::Timers::instance().scheduleEvery([this]() { expirationTimer(); return false; }, SECS_BETWEEN_REQUESTS);
 }
 
 void LLExperienceCache::cleanup()
@@ -125,6 +124,8 @@ void LLExperienceCache::cleanup()
         cache_stream << (*this);
     }
     sShutdown = true;
+
+    LL::Timers::instance().cancel(mExpirationTimerHandle);
 }
 
 //-------------------------------------------------------------------------
@@ -392,30 +393,20 @@ void LLExperienceCache::setCapabilityQuery(LLExperienceCache::CapabilityQuery_t
 }
 
 
-void LLExperienceCache::idleCoro()
+void LLExperienceCache::expirationTimer()
 {
-    const F32 SECS_BETWEEN_REQUESTS = 0.5f;
+    LL_PROFILE_ZONE_SCOPED;
     const F32 ERASE_EXPIRED_TIMEOUT = 60.f; // seconds
 
-    LL_INFOS("ExperienceCache") << "Launching Experience cache idle coro." << LL_ENDL;
-    do
+    if (mEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
     {
-        if (mEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
-        {
-            eraseExpired();
-        }
-
-        if (!mRequestQueue.empty())
-        {
-            requestExperiences();
-        }
-
-        llcoro::suspendUntilTimeout(SECS_BETWEEN_REQUESTS);
-
-    } while (!sShutdown);
+        eraseExpired();
+    }
 
-    // The coroutine system will likely be shut down by the time we get to this point
-    // (or at least no further cycling will occur on it since the user has decided to quit.)
+    if (!mRequestQueue.empty())
+    {
+        requestExperiences();
+    }
 }
 
 void LLExperienceCache::erase(const LLUUID& key)
diff --git a/indra/llmessage/llexperiencecache.h b/indra/llmessage/llexperiencecache.h
index 81e904107f..b10c24efe4 100644
--- a/indra/llmessage/llexperiencecache.h
+++ b/indra/llmessage/llexperiencecache.h
@@ -30,10 +30,13 @@
 #define LL_LLEXPERIENCECACHE_H
 
 #include "linden_common.h"
-#include "llsingleton.h"
+
+#include "llcallbacklist.h" // LL::Timers::handle_t
+#include "llcorehttputil.h"
 #include "llframetimer.h"
+#include "llsingleton.h"
 #include "llsd.h"
-#include "llcorehttputil.h"
+
 #include <boost/signals2.hpp>
 #include <boost/function.hpp>
 
@@ -144,7 +147,9 @@ private:
     std::string     mCacheFileName;
     static bool     sShutdown; // control for coroutines, they exist out of LLExperienceCache's scope, so they need a static control
 
-    void idleCoro();
+    LL::Timers::handle_t mExpirationTimerHandle;
+    void expirationTimer();
+
     void eraseExpired();
     void requestExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &, std::string, RequestQueue_t);
     void requestExperiences();
diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index 798b605f08..9209cdcb51 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -1433,7 +1433,10 @@ void LLGLManager::initExtensions()
     mHasDebugOutput = mGLVersion >= 4.29f;
 
 #if LL_WINDOWS || LL_LINUX
-    mHasNVXGpuMemoryInfo = ExtensionExists("GL_NVX_gpu_memory_info", gGLHExts.mSysExts);
+    if( gGLHExts.mSysExts )
+        mHasNVXGpuMemoryInfo = ExtensionExists("GL_NVX_gpu_memory_info", gGLHExts.mSysExts);
+    else
+        LL_WARNS() << "gGLHExts.mSysExts is not set.?" << LL_ENDL;
 #endif
 
     // Misc
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 6ba5463acd..bbbce1965e 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -1138,6 +1138,28 @@ S32 LLGLSLShader::bindTexture(S32 uniform, LLTexture* texture, LLTexUnit::eTextu
     return uniform;
 }
 
+// For LLImageGL-wrapped textures created via GL elsewhere with our API only. Use with caution.
+S32 LLGLSLShader::bindTextureImageGL(S32 uniform, LLImageGL* texture, LLTexUnit::eTextureType mode)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
+
+    if (uniform < 0 || uniform >= (S32)mTexture.size())
+    {
+        LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << uniform << LL_ENDL;
+        llassert(false);
+        return -1;
+    }
+
+    uniform = mTexture[uniform];
+
+    if (uniform > -1)
+    {
+        gGL.getTexUnit(uniform)->bind(texture);
+    }
+
+    return uniform;
+}
+
 S32 LLGLSLShader::bindTexture(S32 uniform, LLRenderTarget* texture, bool depth, LLTexUnit::eTextureFilterOptions mode, U32 index)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 2d669c70a9..c24daaf686 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -264,6 +264,8 @@ public:
     // You can reuse the return value to unbind a texture when required.
     S32 bindTexture(const std::string& uniform, LLTexture* texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
     S32 bindTexture(S32 uniform, LLTexture* texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    // For LLImageGL-wrapped textures created via GL elsewhere with our API only. Use with caution.
+    S32 bindTextureImageGL(S32 uniform, LLImageGL* texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
     S32 bindTexture(const std::string& uniform, LLRenderTarget* texture, bool depth = false, LLTexUnit::eTextureFilterOptions mode = LLTexUnit::TFO_BILINEAR);
     S32 bindTexture(S32 uniform, LLRenderTarget* texture, bool depth = false, LLTexUnit::eTextureFilterOptions mode = LLTexUnit::TFO_BILINEAR, U32 index = 0);
     S32 unbindTexture(const std::string& uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index ba77c6f1a4..c915fcdf7b 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -1323,12 +1323,16 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
             { //GL_ALPHA is deprecated, convert to RGBA
                 if (pixels != nullptr)
                 {
-                    scratch.reset(new(std::nothrow) U32[width * height]);
-                    if (!scratch)
+                    try
+                    {
+                        scratch.reset(new U32[width * height]);
+                    }
+                    catch (std::bad_alloc)
                     {
                         LLError::LLUserWarningMsg::showOutOfMemory();
                         LL_ERRS() << "Failed to allocate " << (U32)(width * height * sizeof(U32))
-                            << " bytes for a manual image W" << width << " H" << height << LL_ENDL;
+                            << " bytes for a manual image W" << width << " H" << height
+                            << " Pixformat: GL_ALPHA, pixtype: GL_UNSIGNED_BYTE" << LL_ENDL;
                     }
 
                     U32 pixel_count = (U32)(width * height);
@@ -1350,12 +1354,16 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
             { //GL_LUMINANCE_ALPHA is deprecated, convert to RGBA
                 if (pixels != nullptr)
                 {
-                    scratch.reset(new(std::nothrow) U32[width * height]);
-                    if (!scratch)
+                    try
+                    {
+                        scratch.reset(new U32[width * height]);
+                    }
+                    catch (std::bad_alloc)
                     {
                         LLError::LLUserWarningMsg::showOutOfMemory();
                         LL_ERRS() << "Failed to allocate " << (U32)(width * height * sizeof(U32))
-                            << " bytes for a manual image W" << width << " H" << height << LL_ENDL;
+                            << " bytes for a manual image W" << width << " H" << height
+                            << " Pixformat: GL_LUMINANCE_ALPHA, pixtype: GL_UNSIGNED_BYTE" << LL_ENDL;
                     }
 
                     U32 pixel_count = (U32)(width * height);
@@ -1380,12 +1388,16 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
             { //GL_LUMINANCE_ALPHA is deprecated, convert to RGB
                 if (pixels != nullptr)
                 {
-                    scratch.reset(new(std::nothrow) U32[width * height]);
-                    if (!scratch)
+                    try
+                    {
+                        scratch.reset(new U32[width * height]);
+                    }
+                    catch (std::bad_alloc)
                     {
                         LLError::LLUserWarningMsg::showOutOfMemory();
                         LL_ERRS() << "Failed to allocate " << (U32)(width * height * sizeof(U32))
-                            << " bytes for a manual image W" << width << " H" << height << LL_ENDL;
+                            << " bytes for a manual image W" << width << " H" << height
+                            << " Pixformat: GL_LUMINANCE, pixtype: GL_UNSIGNED_BYTE" << LL_ENDL;
                     }
 
                     U32 pixel_count = (U32)(width * height);
diff --git a/indra/llrender/llrender2dutils.cpp b/indra/llrender/llrender2dutils.cpp
index 971241ed05..bec6cb32c4 100644
--- a/indra/llrender/llrender2dutils.cpp
+++ b/indra/llrender/llrender2dutils.cpp
@@ -1693,10 +1693,10 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + height_vec).mV);
 
         gGL.texCoord2f(clip_rect.mLeft, center_uv_rect.mTop);
-        gGL.vertex3fv((center_draw_rect.mTop* height_vec).mV);
+        gGL.vertex3fv((center_draw_rect.mTop * height_vec).mV);
 
-        gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mTop);
-        gGL.vertex3fv((center_draw_rect.mLeft* width_vec + center_draw_rect.mTop * height_vec).mV);
+        gGL.texCoord2f(center_uv_rect.mLeft, clip_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mLeft * width_vec + height_vec).mV);
 
         gGL.texCoord2f(clip_rect.mLeft, clip_rect.mTop);
         gGL.vertex3fv((height_vec).mV);
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 6097b09d96..796805e2a5 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1190,8 +1190,9 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("gltf_material_id"); // (GLTF)
 
     mReservedUniforms.push_back("terrain_texture_transforms"); // (GLTF)
+    mReservedUniforms.push_back("terrain_stamp_scale");
 
-    llassert(mReservedUniforms.size() == LLShaderMgr::TERRAIN_TEXTURE_TRANSFORMS +1);
+    llassert(mReservedUniforms.size() == LLShaderMgr::TERRAIN_STAMP_SCALE +1);
 
     mReservedUniforms.push_back("viewport");
 
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index 1bae0cd8a0..ff07ce454b 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -67,6 +67,7 @@ public:
         GLTF_MATERIAL_ID,                     //  "gltf_material_id" (GLTF)
 
         TERRAIN_TEXTURE_TRANSFORMS,           //  "terrain_texture_transforms" (GLTF)
+        TERRAIN_STAMP_SCALE,                  //  "terrain_stamp_scale"
 
         VIEWPORT,                           //  "viewport"
         LIGHT_POSITION,                     //  "light_position"
diff --git a/indra/llui/llemojihelper.cpp b/indra/llui/llemojihelper.cpp
index b9441a9c91..b2c59ce775 100644
--- a/indra/llui/llemojihelper.cpp
+++ b/indra/llui/llemojihelper.cpp
@@ -99,6 +99,7 @@ void LLEmojiHelper::showHelper(LLUICtrl* hostctrl_p, S32 local_x, S32 local_y, c
         LLFloater* pHelperFloater = LLFloaterReg::getInstance(DEFAULT_EMOJI_HELPER_FLOATER);
         mHelperHandle = pHelperFloater->getHandle();
         mHelperCommitConn = pHelperFloater->setCommitCallback(std::bind([&](const LLSD& sdValue) { onCommitEmoji(utf8str_to_wstring(sdValue.asStringRef())[0]); }, std::placeholders::_2));
+        mHelperCloseConn = pHelperFloater->setCloseCallback([this](LLUICtrl* ctrl, const LLSD& param) { onCloseHelper(ctrl, param); });
     }
     setHostCtrl(hostctrl_p);
     mEmojiCommitCb = cb;
@@ -148,6 +149,16 @@ void LLEmojiHelper::onCommitEmoji(llwchar emoji)
     }
 }
 
+void LLEmojiHelper::onCloseHelper(LLUICtrl* ctrl, const LLSD& param)
+{
+    mCloseSignal(ctrl, param);
+}
+
+boost::signals2::connection LLEmojiHelper::setCloseCallback(const commit_signal_t::slot_type& cb)
+{
+    return mCloseSignal.connect(cb);
+}
+
 void LLEmojiHelper::setHostCtrl(LLUICtrl* hostctrl_p)
 {
     const LLUICtrl* pCurHostCtrl = mHostHandle.get();
diff --git a/indra/llui/llemojihelper.h b/indra/llui/llemojihelper.h
index 2834b06061..26840eef94 100644
--- a/indra/llui/llemojihelper.h
+++ b/indra/llui/llemojihelper.h
@@ -51,16 +51,23 @@ public:
     // Eventing
     bool handleKey(const LLUICtrl* ctrl_p, KEY key, MASK mask);
     void onCommitEmoji(llwchar emoji);
+    void onCloseHelper(LLUICtrl* ctrl, const LLSD& param);
+
+    typedef boost::signals2::signal<void(LLUICtrl* ctrl, const LLSD& param)> commit_signal_t;
+    boost::signals2::connection setCloseCallback(const commit_signal_t::slot_type& cb);
 
 protected:
     LLUICtrl* getHostCtrl() const { return mHostHandle.get(); }
     void      setHostCtrl(LLUICtrl* hostctrl_p);
 
 private:
+    commit_signal_t mCloseSignal;
+
     LLHandle<LLUICtrl>  mHostHandle;
     LLHandle<LLFloater> mHelperHandle;
     boost::signals2::connection mHostCtrlFocusLostConn;
     boost::signals2::connection mHelperCommitConn;
+    boost::signals2::connection mHelperCloseConn;
     std::function<void(llwchar)> mEmojiCommitCb;
     bool mIsHideDisabled;
 };
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
index 5bdbcdfcf8..9e1594bdd2 100644
--- a/indra/llui/llfloater.h
+++ b/indra/llui/llfloater.h
@@ -377,6 +377,10 @@ public:
     void            enableResizeCtrls(bool enable, bool width = true, bool height = true);
 
     bool            isPositioning(LLFloaterEnums::EOpenPositioning p) const { return (p == mPositioning); }
+
+    void            setAutoFocus(bool focus) { mAutoFocus = focus; } // whether to automatically take focus when opened
+    bool            getAutoFocus() const { return mAutoFocus; }
+
 protected:
     void            applyControlsAndPosition(LLFloater* other);
 
@@ -401,8 +405,6 @@ protected:
     void            setExpandedRect(const LLRect& rect) { mExpandedRect = rect; } // size when not minimized
     const LLRect&   getExpandedRect() const { return mExpandedRect; }
 
-    void            setAutoFocus(bool focus) { mAutoFocus = focus; } // whether to automatically take focus when opened
-    bool            getAutoFocus() const { return mAutoFocus; }
     LLDragHandle*   getDragHandle() const { return mDragHandle; }
 
     void            destroy(); // Don't call this directly.  You probably want to call closeFloater()
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
index 66b274c33f..c0abba4358 100644
--- a/indra/llui/lllineeditor.cpp
+++ b/indra/llui/lllineeditor.cpp
@@ -122,6 +122,7 @@ LLLineEditor::Params::Params()
 
 LLLineEditor::LLLineEditor(const LLLineEditor::Params& p)
 :   LLUICtrl(p),
+    mDefaultText(p.default_text),
     mMaxLengthBytes(p.max_length.bytes),
     mMaxLengthChars(p.max_length.chars),
     mCursorPos( 0 ),
diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
index 7533f76f1d..65f167bc6b 100644
--- a/indra/llui/lllineeditor.h
+++ b/indra/llui/lllineeditor.h
@@ -202,6 +202,7 @@ public:
     void            setLabel(const LLStringExplicit &new_label) { mLabel = new_label; }
     const std::string&  getLabel()  { return mLabel.getString(); }
 
+    void            setDefaultText() { setText(mDefaultText); }
     void            setText(const LLStringExplicit &new_text);
 
     const std::string& getText() const override { return mText.getString(); }
@@ -347,6 +348,7 @@ protected:
     LLFontVertexBuffer mFontBufferSelection;
     LLFontVertexBuffer mFontBufferPostSelection;
     LLFontVertexBuffer mFontBufferLabel;
+    std::string mDefaultText;
     S32         mMaxLengthBytes;            // Max length of the UTF8 string in bytes
     S32         mMaxLengthChars;            // Maximum number of characters in the string
     S32         mCursorPos;                 // I-beam is just after the mCursorPos-th character.
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index ddd1d81cb4..8093536868 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -1105,38 +1105,32 @@ S32 LLScrollListCtrl::getItemIndex( const LLUUID& target_id ) const
 
 void LLScrollListCtrl::selectPrevItem( bool extend_selection)
 {
+    updateSort();
+
     LLScrollListItem* prev_item = NULL;
 
-    if (!getFirstSelected())
-    {
-        // select last item
-        selectNthItem(getItemCount() - 1);
-    }
-    else
+    for (LLScrollListItem* item : mItemList)
     {
-        updateSort();
-
-        item_list::iterator iter;
-        for (LLScrollListItem* cur_item : mItemList)
+        if (item->getSelected())
         {
-            if (cur_item->getSelected())
-            {
-                if (prev_item)
-                {
-                    selectItem(prev_item, cur_item->getSelectedCell(), !extend_selection);
-                }
-                else
-                {
-                    reportInvalidInput();
-                }
-                break;
-            }
+            break;
+        }
 
-            // don't allow navigation to disabled elements
-            prev_item = cur_item->getEnabled() ? cur_item : prev_item;
+        // don't allow navigation to disabled elements
+        if (item->getEnabled())
+        {
+            prev_item = item;
         }
     }
 
+    if (!prev_item)
+    {
+        reportInvalidInput();
+        return;
+    }
+
+    selectItem(prev_item, prev_item->getSelectedCell(), !extend_selection);
+
     if ((mCommitOnSelectionChange || mCommitOnKeyboardMovement))
     {
         commitIfChanged();
@@ -1147,36 +1141,41 @@ void LLScrollListCtrl::selectPrevItem( bool extend_selection)
 
 void LLScrollListCtrl::selectNextItem( bool extend_selection)
 {
+    updateSort();
+
+    LLScrollListItem* current_item = NULL;
     LLScrollListItem* next_item = NULL;
 
-    if (!getFirstSelected())
-    {
-        selectFirstItem();
-    }
-    else
+    for (LLScrollListItem* item : mItemList)
     {
-        updateSort();
-
-        for (LLScrollListItem* cur_item : mItemList)
+        if (current_item)
         {
-            if (cur_item->getSelected())
+            if (item->getEnabled())
             {
-                if (next_item)
-                {
-                    selectItem(next_item, cur_item->getSelectedCell(), !extend_selection);
-                }
-                else
-                {
-                    reportInvalidInput();
-                }
+                next_item = item;
                 break;
             }
-
-            // don't allow navigation to disabled items
-            next_item = cur_item->getEnabled() ? cur_item : next_item;
         }
+        else if (item->getSelected())
+        {
+            current_item = item;
+            next_item = NULL;
+            continue;
+        }
+        else if (!next_item && item->getEnabled())
+        {
+            next_item = item;
+        }
+    }
+
+    if (!next_item)
+    {
+        reportInvalidInput();
+        return;
     }
 
+    selectItem(next_item, next_item->getSelectedCell(), !extend_selection);
+
     if (mCommitOnKeyboardMovement)
     {
         onCommit();
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index ecac800def..088fbe2744 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -1211,6 +1211,14 @@ void LLTextEditor::showEmojiHelper()
     LLEmojiHelper::instance().showHelper(this, cursorRect.mLeft, cursorRect.mTop, LLStringUtil::null, cb);
 }
 
+void LLTextEditor::hideEmojiHelper()
+{
+    if (mShowEmojiHelper)
+    {
+        LLEmojiHelper::instance().hideHelper(this);
+    }
+}
+
 void LLTextEditor::tryToShowEmojiHelper()
 {
     if (mReadOnly || !mShowEmojiHelper)
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index cedb79bf62..32dd95b8ac 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -207,6 +207,7 @@ public:
     bool            getShowContextMenu() const { return mShowContextMenu; }
 
     void            showEmojiHelper();
+    void            hideEmojiHelper();
     void            setShowEmojiHelper(bool show);
     bool            getShowEmojiHelper() const { return mShowEmojiHelper; }
 
diff --git a/indra/llwebrtc/llwebrtc.cpp b/indra/llwebrtc/llwebrtc.cpp
index 0daa767766..a73962f3d6 100644
--- a/indra/llwebrtc/llwebrtc.cpp
+++ b/indra/llwebrtc/llwebrtc.cpp
@@ -45,6 +45,10 @@ static int16_t PLAYOUT_DEVICE_BAD     = -2;
 static int16_t RECORD_DEVICE_DEFAULT  = -1;
 static int16_t RECORD_DEVICE_BAD      = -2;
 
+static const std::string DEFAULT_DEVICE_NAME = "Default";
+static const std::string NO_DEVICE_NAME = "No Device";
+static const std::string NO_DEVICE_GUID;
+
 LLAudioDeviceObserver::LLAudioDeviceObserver() : mSumVector {0}, mMicrophoneEnergy(0.0) {}
 
 float LLAudioDeviceObserver::getMicrophoneEnergy() { return mMicrophoneEnergy; }
@@ -438,7 +442,7 @@ void ll_set_device_module_capture_device(rtc::scoped_refptr<webrtc::AudioDeviceM
 void LLWebRTCImpl::setCaptureDevice(const std::string &id)
 {
     int16_t recordingDevice = RECORD_DEVICE_DEFAULT;
-    if (id != "Default")
+    if (id != DEFAULT_DEVICE_NAME)
     {
         for (int16_t i = 0; i < mRecordingDeviceList.size(); i++)
         {
@@ -502,7 +506,7 @@ void ll_set_device_module_render_device(rtc::scoped_refptr<webrtc::AudioDeviceMo
 void LLWebRTCImpl::setRenderDevice(const std::string &id)
 {
     int16_t playoutDevice = PLAYOUT_DEVICE_DEFAULT;
-    if (id != "Default")
+    if (id != DEFAULT_DEVICE_NAME)
     {
         for (int16_t i = 0; i < mPlayoutDeviceList.size(); i++)
         {
@@ -546,6 +550,16 @@ void LLWebRTCImpl::setRenderDevice(const std::string &id)
     }
 }
 
+bool LLWebRTCImpl::isCaptureNoDevice()
+{
+    return mRecordingDevice == mRecordingNoDevice;
+}
+
+bool LLWebRTCImpl::isRenderNoDevice()
+{
+    return mPlayoutDevice == mPlayoutNoDevice;
+}
+
 // updateDevices needs to happen on the worker thread.
 void LLWebRTCImpl::updateDevices()
 {
@@ -566,6 +580,11 @@ void LLWebRTCImpl::updateDevices()
         mTuningDeviceModule->PlayoutDeviceName(index, name, guid);
         mPlayoutDeviceList.emplace_back(name, guid);
     }
+    mPlayoutNoDevice = (int32_t)mPlayoutDeviceList.size();
+    if (mPlayoutNoDevice)
+    {
+        mPlayoutDeviceList.emplace_back(NO_DEVICE_NAME, NO_DEVICE_GUID);
+    }
 
     int16_t captureDeviceCount        = mTuningDeviceModule->RecordingDevices();
 
@@ -584,6 +603,11 @@ void LLWebRTCImpl::updateDevices()
         mTuningDeviceModule->RecordingDeviceName(index, name, guid);
         mRecordingDeviceList.emplace_back(name, guid);
     }
+    mRecordingNoDevice = (int32_t)mRecordingDeviceList.size();
+    if (mRecordingNoDevice)
+    {
+        mRecordingDeviceList.emplace_back(NO_DEVICE_NAME, NO_DEVICE_GUID);
+    }
 
     for (auto &observer : mVoiceDevicesObserverList)
     {
@@ -933,20 +957,20 @@ void LLWebRTCPeerConnectionImpl::AnswerAvailable(const std::string &sdp)
 void LLWebRTCPeerConnectionImpl::setMute(bool mute)
 {
     mMute = mute;
+    mute |= mWebRTCImpl->isCaptureNoDevice();
     mWebRTCImpl->PostSignalingTask(
-        [this]()
+        [&]()
         {
         if (mPeerConnection)
         {
             auto senders = mPeerConnection->GetSenders();
 
-            RTC_LOG(LS_INFO) << __FUNCTION__ << (mMute ? "disabling" : "enabling") << " streams count " << senders.size();
+            RTC_LOG(LS_INFO) << __FUNCTION__ << (mute ? "disabling" : "enabling") << " streams count " << senders.size();
             for (auto &sender : senders)
             {
-                auto track = sender->track();
-                if (track)
+                if (auto track = sender->track())
                 {
-                    track->set_enabled(!mMute);
+                    track->set_enabled(!mute);
                 }
             }
         }
@@ -960,6 +984,11 @@ void LLWebRTCPeerConnectionImpl::resetMute()
 
 void LLWebRTCPeerConnectionImpl::setReceiveVolume(float volume)
 {
+    if (mWebRTCImpl->isRenderNoDevice())
+    {
+        volume = 0;
+    }
+
     mWebRTCImpl->PostSignalingTask(
         [this, volume]()
         {
diff --git a/indra/llwebrtc/llwebrtc.h b/indra/llwebrtc/llwebrtc.h
index c6fdb909dd..2deaba9e58 100644
--- a/indra/llwebrtc/llwebrtc.h
+++ b/indra/llwebrtc/llwebrtc.h
@@ -151,6 +151,9 @@ class LLWebRTCDeviceInterface
     virtual void setCaptureDevice(const std::string& id) = 0;
     virtual void setRenderDevice(const std::string& id) = 0;
 
+    virtual bool isCaptureNoDevice() = 0;
+    virtual bool isRenderNoDevice() = 0;
+
     // Device observers for device change callbacks.
     virtual void setDevicesObserver(LLWebRTCDevicesObserver *observer) = 0;
     virtual void unsetDevicesObserver(LLWebRTCDevicesObserver *observer) = 0;
diff --git a/indra/llwebrtc/llwebrtc_impl.h b/indra/llwebrtc/llwebrtc_impl.h
index b93a1fdb01..27b7eae8e7 100644
--- a/indra/llwebrtc/llwebrtc_impl.h
+++ b/indra/llwebrtc/llwebrtc_impl.h
@@ -210,6 +210,9 @@ class LLWebRTCImpl : public LLWebRTCDeviceInterface, public webrtc::AudioDeviceS
     void setCaptureDevice(const std::string& id) override;
     void setRenderDevice(const std::string& id) override;
 
+    bool isCaptureNoDevice() override;
+    bool isRenderNoDevice() override;
+
     void setTuningMode(bool enable) override;
     float getTuningAudioLevel() override;
     float getPeerConnectionAudioLevel() override;
@@ -306,9 +309,11 @@ class LLWebRTCImpl : public LLWebRTCDeviceInterface, public webrtc::AudioDeviceS
     // accessors in native webrtc for devices aren't apparently implemented yet.
     bool                                                       mTuningMode;
     int32_t                                                    mRecordingDevice;
+    int32_t                                                    mRecordingNoDevice;
     LLWebRTCVoiceDeviceList                                    mRecordingDeviceList;
 
     int32_t                                                    mPlayoutDevice;
+    int32_t                                                    mPlayoutNoDevice;
     LLWebRTCVoiceDeviceList                                    mPlayoutDeviceList;
 
     bool                                                       mMute;
diff --git a/indra/llwindow/llsdl.cpp b/indra/llwindow/llsdl.cpp
index 6161bd2972..3f7992a1d7 100644
--- a/indra/llwindow/llsdl.cpp
+++ b/indra/llwindow/llsdl.cpp
@@ -56,6 +56,7 @@ void init_sdl()
     std::initializer_list<std::tuple< char const*, char const * > > hintList =
             {
                     {SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR,"0"},
+                    {SDL_HINT_VIDEODRIVER,"wayland,x11"},
                     {SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH,"1"},
                     {SDL_HINT_IME_INTERNAL_EDITING,"1"}
             };
diff --git a/indra/llwindow/llwindowsdl.cpp b/indra/llwindow/llwindowsdl.cpp
index ea95a5aa2e..4793ab4fc7 100644
--- a/indra/llwindow/llwindowsdl.cpp
+++ b/indra/llwindow/llwindowsdl.cpp
@@ -50,10 +50,10 @@ extern "C" {
 #if LL_LINUX
 // not necessarily available on random SDL platforms, so #if LL_LINUX
 // for execv(), waitpid(), fork()
-# include <unistd.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdio.h>
 #endif // LL_LINUX
 
 extern bool gDebugWindowProc;
@@ -64,52 +64,170 @@ const S32 MAX_NUM_RESOLUTIONS = 200;
 // LLWindowSDL
 //
 
-#if LL_X11
-# include <X11/Xutil.h>
-#endif //LL_X11
+#include <X11/Xutil.h>
 
 // TOFU HACK -- (*exactly* the same hack as LLWindowMacOSX for a similar
 // set of reasons): Stash a pointer to the LLWindowSDL object here and
 // maintain in the constructor and destructor.  This assumes that there will
 // be only one object of this class at any time.  Currently this is true.
-static LLWindowSDL *gWindowImplementation = NULL;
-
+static LLWindowSDL *gWindowImplementation = nullptr;
 
 void maybe_lock_display(void)
 {
-    if (gWindowImplementation && gWindowImplementation->Lock_Display) {
+    if (gWindowImplementation && gWindowImplementation->Lock_Display)
         gWindowImplementation->Lock_Display();
-    }
 }
 
-
 void maybe_unlock_display(void)
 {
-    if (gWindowImplementation && gWindowImplementation->Unlock_Display) {
+    if (gWindowImplementation && gWindowImplementation->Unlock_Display)
         gWindowImplementation->Unlock_Display();
-    }
 }
 
 
-#if LL_X11
-// static
 Window LLWindowSDL::get_SDL_XWindowID(void)
 {
-    if (gWindowImplementation) {
-        return gWindowImplementation->mSDL_XWindowID;
-    }
+    if (gWindowImplementation)
+        return gWindowImplementation->mX11Data.mXWindowID;
     return None;
 }
 
-//static
 Display* LLWindowSDL::get_SDL_Display(void)
 {
-    if (gWindowImplementation) {
-        return gWindowImplementation->mSDL_Display;
+    if (gWindowImplementation)
+        return gWindowImplementation->mX11Data.mDisplay;
+    return nullptr;
+}
+
+/*
+ * In wayland a window does not have a state of "minimized" or gets messages that it got minimized [1]
+ * There's two ways to approach this challenge:
+ *   1) Ignore it, this would mean even if minimized/not visible the viewer will always fun at full fps
+ *   2) Try to detect something like "minimized", the best way I found so far is to as for frame_done events. Those will
+ *   only happen if parts of the viewer are visible. As such it is not the same a "minimized" but rather "this window
+ *   is not fully hidden behind another window or minimized". That's (I guess) still better than nothing and running
+ *   full tilt even if hidden.
+ *
+ * [1] As of 2024-09, maybe in the future we get nice things
+*/
+#ifdef LL_WAYLAND
+#include <wayland-client-protocol.h>
+#include <dlfcn.h>
+
+bool LLWindowSDL::isWaylandWindowNotDrawing() const
+{
+    if( Wayland != mServerProtocol || mWaylandData.mLastFrameEvent == 0 )
+        return false;
+
+    auto currentTime = LLTimer::getTotalTime();
+    if( (currentTime - mWaylandData.mLastFrameEvent) > 250000 )
+        return true;
+
+    return false;
+}
+
+uint32_t (*ll_wl_proxy_get_version)(struct wl_proxy *proxy);
+void (*ll_wl_proxy_destroy)(struct wl_proxy *proxy);
+int (*ll_wl_proxy_add_listener)(struct wl_proxy *proxy, void (**implementation)(void), void *data);
+
+wl_interface  *ll_wl_callback_interface;
+
+int ll_wl_callback_add_listener(struct wl_callback *wl_callback,
+                         const struct wl_callback_listener *listener, void *data)
+{
+    return ll_wl_proxy_add_listener((struct wl_proxy *) wl_callback,
+                                 (void (**)(void)) listener, data);
+}
+
+struct wl_proxy* (*ll_wl_proxy_marshal_flags)(struct wl_proxy *proxy, uint32_t opcode,
+                       const struct wl_interface *interface,
+                       uint32_t version,
+                       uint32_t flags, ...);
+
+
+bool loadWaylandClient()
+{
+    auto *pSO = dlopen( "libwayland-client.so.0", RTLD_NOW);
+    if( !pSO )
+        return false;
+
+
+    ll_wl_callback_interface = (wl_interface*)dlsym(pSO, "wl_callback_interface");
+    *(void**)&ll_wl_proxy_marshal_flags = dlsym(pSO, "wl_proxy_marshal_flags");
+    *(void**)&ll_wl_proxy_get_version = dlsym(pSO, "wl_proxy_get_version");
+    *(void**)&ll_wl_proxy_destroy = dlsym(pSO, "wl_proxy_destroy");
+    *(void**)&ll_wl_proxy_add_listener = dlsym(pSO, "wl_proxy_add_listener");
+
+    return ll_wl_callback_interface != nullptr && ll_wl_proxy_marshal_flags != nullptr &&
+            ll_wl_proxy_get_version != nullptr && ll_wl_proxy_destroy != nullptr &&
+            ll_wl_proxy_add_listener != nullptr;
+}
+
+struct wl_callback* ll_wl_surface_frame(struct wl_surface *wl_surface)
+{
+    auto version = ll_wl_proxy_get_version((struct wl_proxy *) wl_surface);
+
+    auto callback = ll_wl_proxy_marshal_flags((struct wl_proxy *) wl_surface,
+                                      WL_SURFACE_FRAME, ll_wl_callback_interface, version,
+                                      0, nullptr);
+
+    return (struct wl_callback *) callback;
+}
+
+void ll_wl_callback_destroy(struct wl_callback *wl_callback)
+{
+    ll_wl_proxy_destroy((struct wl_proxy *) wl_callback);
+}
+
+void LLWindowSDL::waylandFrameDoneCB(void *data, struct wl_callback *cb, uint32_t time)
+{
+    static uint32_t frame_count {0};
+    static F64SecondsImplicit lastInfo{0};
+
+    ++frame_count;
+
+    ll_wl_callback_destroy(cb);
+    auto pThis = reinterpret_cast<LLWindowSDL*>(data);
+    pThis->mWaylandData.mLastFrameEvent = LLTimer::getTotalTime();
+
+    auto now = LLTimer::getElapsedSeconds();
+    if( lastInfo > 0)
+    {
+        auto diff = now.value() - lastInfo.value();
+        constexpr double FPS_INFO_INTERVAL = 60.f * 5.f;
+        if( diff >= FPS_INFO_INTERVAL)
+        {
+            double fFPS = frame_count;
+            fFPS /= diff;
+            LL_INFOS() << "Wayland: FPS " << fFPS << " fps, " << frame_count << " #frames time " << (diff) << LL_ENDL;
+            frame_count = 0;
+            lastInfo = now;
+        }
     }
-    return NULL;
+    else
+        lastInfo = now;
+
+    pThis->setupWaylandFrameCallback(); // ask for a new frame
 }
-#endif // LL_X11
+
+void LLWindowSDL::setupWaylandFrameCallback()
+{
+    static  wl_callback_listener frame_listener { nullptr };
+    frame_listener.done = &LLWindowSDL::waylandFrameDoneCB;
+
+    auto cb = ll_wl_surface_frame(mWaylandData.mSurface);
+    ll_wl_callback_add_listener(cb, &frame_listener, this);
+}
+#else
+bool LLWindowSDL::isWaylandWindowNotDrawing()
+{
+    return false;
+}
+void LLWindowSDL::setupWaylandFrameCallback()
+{
+    LL_WARNS() << "Viewer is running under Wayland, but was not compiled with full wayland support!" << LL_ENDL;
+}
+#endif
 
 LLWindowSDL::LLWindowSDL(LLWindowCallbacks* callbacks,
                          const std::string& title, const std::string& name, S32 x, S32 y, S32 width,
@@ -118,29 +236,12 @@ LLWindowSDL::LLWindowSDL(LLWindowCallbacks* callbacks,
                          bool enable_vsync, bool use_gl,
                          bool ignore_pixel_depth, U32 fsaa_samples)
         : LLWindow(callbacks, fullscreen, flags),
-        Lock_Display(NULL),
-        Unlock_Display(NULL), mGamma(1.0f)
+        Lock_Display(nullptr),
+        Unlock_Display(nullptr), mGamma(1.0f)
 {
     // Initialize the keyboard
     gKeyboard = new LLKeyboardSDL();
     gKeyboard->setCallbacks(callbacks);
-    // Note that we can't set up key-repeat until after SDL has init'd video
-
-    // Ignore use_gl for now, only used for drones on PC
-    mWindow = NULL;
-    mContext = {};
-    mNeedsResize = false;
-    mOverrideAspectRatio = 0.f;
-    mGrabbyKeyFlags = 0;
-    mReallyCapturedCount = 0;
-    mHaveInputFocus = -1;
-    mIsMinimized = -1;
-    mFSAASamples = fsaa_samples;
-
-#if LL_X11
-    mSDL_XWindowID = None;
-    mSDL_Display = nullptr;
-#endif // LL_X11
 
     // Assume 4:3 aspect ratio until we know better
     mOriginalAspectRatio = 1024.0 / 768.0;
@@ -167,8 +268,6 @@ LLWindowSDL::LLWindowSDL(LLWindowCallbacks* callbacks,
 
     mFlashing = false;
 
-    mKeyVirtualKey = 0;
-    mKeyModifiers = KMOD_NONE;
 }
 
 static SDL_Surface *Load_BMP_Resource(const char *basename)
@@ -197,7 +296,7 @@ void LLWindowSDL::tryFindFullscreenSize( int &width, int &height )
     LL_INFOS() << "createContext: setting up fullscreen " << width << "x" << height << LL_ENDL;
 
     // If the requested width or height is 0, find the best default for the monitor.
-    if((width == 0) || (height == 0))
+    if(width == 0 || height == 0)
     {
         // Scan through the list of modes, looking for one which has:
         //      height between 700 and 800
@@ -205,16 +304,15 @@ void LLWindowSDL::tryFindFullscreenSize( int &width, int &height )
         S32 resolutionCount = 0;
         LLWindowResolution *resolutionList = getSupportedResolutions(resolutionCount);
 
-        if(resolutionList != NULL)
+        if(resolutionList != nullptr)
         {
             F32 closestAspect = 0;
             U32 closestHeight = 0;
             U32 closestWidth = 0;
-            int i;
 
             LL_INFOS() << "createContext: searching for a display mode, original aspect is " << mOriginalAspectRatio << LL_ENDL;
 
-            for(i=0; i < resolutionCount; i++)
+            for(S32 i=0; i < resolutionCount; i++)
             {
                 F32 aspect = (F32)resolutionList[i].mWidth / (F32)resolutionList[i].mHeight;
 
@@ -237,7 +335,7 @@ void LLWindowSDL::tryFindFullscreenSize( int &width, int &height )
         }
     }
 
-    if((width == 0) || (height == 0))
+    if(width == 0 || height == 0)
     {
         // Mode search failed for some reason.  Use the old-school default.
         width = 1024;
@@ -247,16 +345,10 @@ void LLWindowSDL::tryFindFullscreenSize( int &width, int &height )
 
 bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, bool fullscreen, bool enable_vsync)
 {
-    if (width == 0)
-        width = 1024;
-    if (height == 0)
-        width = 768;
-    LL_INFOS() << "createContext, fullscreen=" << fullscreen <<
-               " size=" << width << "x" << height << LL_ENDL;
+    LL_INFOS() << "createContext, fullscreen=" << fullscreen << " size=" << width << "x" << height << LL_ENDL;
 
     // captures don't survive contexts
     mGrabbyKeyFlags = 0;
-    mReallyCapturedCount = 0;
 
     if (width == 0)
         width = 1024;
@@ -269,15 +361,6 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
 
     mFullscreen = fullscreen;
 
-    int sdlflags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
-
-    if( mFullscreen )
-    {
-        sdlflags |= SDL_WINDOW_FULLSCREEN;
-        tryFindFullscreenSize( width, height );
-    }
-
-    mSDLFlags = sdlflags;
 
     // Setup default backing colors
     GLint redBits{8}, greenBits{8}, blueBits{8}, alphaBits{8};
@@ -300,13 +383,19 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
     SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, context_flags);
     SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
 
-    // Create the window
-    mWindow = SDL_CreateWindow(mWindowTitle.c_str(), x, y, width, height, mSDLFlags);
+    int sdlflags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
+
+    if( mFullscreen )
+    {
+        sdlflags |= SDL_WINDOW_FULLSCREEN;
+        tryFindFullscreenSize( width, height );
+    }
+
+    mWindow = SDL_CreateWindow( mWindowTitle.c_str(), x, y, width, height, sdlflags );
     if (mWindow == nullptr)
     {
         LL_WARNS() << "Window creation failure. SDL: " << SDL_GetError() << LL_ENDL;
         setupFailure("Window creation error", "Error", OSMB_OK);
-        return false;
     }
 
     // Create the context
@@ -315,14 +404,12 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
     {
         LL_WARNS() << "Cannot create GL context " << SDL_GetError() << LL_ENDL;
         setupFailure("GL Context creation error", "Error", OSMB_OK);
-        return false;
     }
 
     if (SDL_GL_MakeCurrent(mWindow, mContext) != 0)
     {
         LL_WARNS() << "Failed to make context current. SDL: " << SDL_GetError() << LL_ENDL;
         setupFailure("GL Context failed to set current failure", "Error", OSMB_OK);
-        return false;
     }
 
     mSurface = SDL_GetWindowSurface(mWindow);
@@ -345,7 +432,7 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
         else
         {
             LL_WARNS() << "createContext: fullscreen creation failure. SDL: " << SDL_GetError() << LL_ENDL;
-            // No fullscreen support
+
             mFullscreen = false;
             mFullscreenWidth   = -1;
             mFullscreenHeight  = -1;
@@ -353,8 +440,7 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
             mFullscreenRefresh = -1;
 
             std::string error = llformat("Unable to run fullscreen at %d x %d.\nRunning in window.", width, height);
-            OSMessageBox(error, "Error", OSMB_OK);
-            return false;
+            setupFailure( error, "Error", OSMB_OK );
         }
     }
     else
@@ -363,7 +449,6 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
         {
             LL_WARNS() << "createContext: window creation failure. SDL: " << SDL_GetError() << LL_ENDL;
             setupFailure("Window creation error", "Error", OSMB_OK);
-            return false;
         }
     }
 
@@ -397,7 +482,6 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
                 "will automatically adjust the screen each time it runs.",
                 "Error",
                 OSMB_OK);
-        return false;
     }
 
     LL_PROFILER_GPU_CONTEXT;
@@ -411,10 +495,9 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
     {
         SDL_SetWindowIcon(mWindow, bmpsurface);
         SDL_FreeSurface(bmpsurface);
-        bmpsurface = NULL;
+        bmpsurface = nullptr;
     }
 
-#if LL_X11
     /* Grab the window manager specific information */
     SDL_SysWMinfo info;
     SDL_VERSION(&info.version);
@@ -423,21 +506,46 @@ bool LLWindowSDL::createContext(int x, int y, int width, int height, int bits, b
         /* Save the information for later use */
         if ( info.subsystem == SDL_SYSWM_X11 )
         {
-            mSDL_Display = info.info.x11.display;
-            mSDL_XWindowID = info.info.x11.window;
+            SDL_SetHint(SDL_HINT_VIDEODRIVER, "x11");
+            mX11Data.mDisplay = info.info.x11.display;
+            mX11Data.mXWindowID = info.info.x11.window;
+            mServerProtocol = X11;
+            LL_INFOS() << "Running under X11" << LL_ENDL;
+        }
+        else if ( info.subsystem == SDL_SYSWM_WAYLAND )
+        {
+#ifdef LL_WAYLAND
+            if( !loadWaylandClient() ) {
+                SDL_SetHint(SDL_HINT_VIDEODRIVER, "x11");
+                LL_ERRS() << "Failed to load wayland-client.so or grab required functions" << LL_ENDL;
+            } else {
+                SDL_SetHint(SDL_HINT_VIDEODRIVER, "wayland");
+            }
+
+            mWaylandData.mSurface = info.info.wl.surface;
+            mServerProtocol = Wayland;
+            setupWaylandFrameCallback();
+
+            // If set (XWayland) remove DISPLAY, this will prompt dullahan to also use Wayland
+            if( getenv("DISPLAY") )
+                unsetenv("DISPLAY");
+
+            LL_INFOS() << "Running under Wayland" << LL_ENDL;
+            LL_WARNS() << "Be aware that with at least SDL2 the window will not receive minimizing events, thus minimized state can only be estimated."
+                          "also setting the application icon via SDL_SetWindowIcon does not work." << LL_ENDL;
+#else
+            setupFailure("Viewer is running under Wayland, but was not compiled with full wayland support!\nYou can compile the viewer with wayland prelimiary support using COMPILE_WAYLAND_SUPPORT", "Error", OSMB_OK);
+#endif
         }
         else
         {
-            LL_WARNS() << "We're not running under X11?  Wild."
-                       << LL_ENDL;
+            LL_WARNS() << "We're not running under X11 or Wayland?  Wild." << LL_ENDL;
         }
     }
     else
     {
-        LL_WARNS() << "We're not running under any known WM.  Wild."
-                   << LL_ENDL;
+        LL_WARNS() << "We're not running under any known WM. Wild." << LL_ENDL;
     }
-#endif // LL_X11
 
     SDL_StartTextInput();
     //make sure multisampling is disabled by default
@@ -523,12 +631,11 @@ void LLWindowSDL::destroyContext()
     LL_INFOS() << "shutdownGL begins" << LL_ENDL;
     gGLManager.shutdownGL();
 
-#if LL_X11
-    mSDL_Display = NULL;
-    mSDL_XWindowID = None;
-    Lock_Display = NULL;
-    Unlock_Display = NULL;
-#endif // LL_X11
+    mX11Data.mDisplay = nullptr;
+    mX11Data.mXWindowID = None;
+    Lock_Display = nullptr;
+    Unlock_Display = nullptr;
+    mServerProtocol = Unknown;
 
     LL_INFOS() << "Destroying SDL cursors" << LL_ENDL;
     quitCursors();
@@ -564,12 +671,9 @@ LLWindowSDL::~LLWindowSDL()
 {
     destroyContext();
 
-    if(mSupportedResolutions != NULL)
-    {
-        delete []mSupportedResolutions;
-    }
+    delete []mSupportedResolutions;
 
-    gWindowImplementation = NULL;
+    gWindowImplementation = nullptr;
 }
 
 
@@ -589,7 +693,6 @@ void LLWindowSDL::hide()
     }
 }
 
-//virtual
 void LLWindowSDL::minimize()
 {
     if (mWindow)
@@ -598,7 +701,6 @@ void LLWindowSDL::minimize()
     }
 }
 
-//virtual
 void LLWindowSDL::restore()
 {
     if (mWindow)
@@ -611,12 +713,6 @@ void LLWindowSDL::restore()
 // Usually called from LLWindowManager::destroyWindow()
 void LLWindowSDL::close()
 {
-    // Is window is already closed?
-    //  if (!mWindow)
-    //  {
-    //      return;
-    //  }
-
     // Make sure cursor is visible and we haven't mangled the clipping state.
     setMouseClipping(false);
     showCursor();
@@ -626,7 +722,7 @@ void LLWindowSDL::close()
 
 bool LLWindowSDL::isValid()
 {
-    return (mWindow != NULL);
+    return mWindow != nullptr;
 }
 
 bool LLWindowSDL::getVisible() const
@@ -645,6 +741,9 @@ bool LLWindowSDL::getVisible() const
 
 bool LLWindowSDL::getMinimized() const
 {
+    if( isWaylandWindowNotDrawing() )
+        return true;
+
     bool result = false;
     if (mWindow)
     {
@@ -698,10 +797,10 @@ bool LLWindowSDL::getSize(LLCoordScreen *size) const
     {
         size->mX = mSurface->w;
         size->mY = mSurface->h;
-        return (true);
+        return true;
     }
 
-    return (false);
+    return false;
 }
 
 bool LLWindowSDL::getSize(LLCoordWindow *size) const
@@ -710,10 +809,10 @@ bool LLWindowSDL::getSize(LLCoordWindow *size) const
     {
         size->mX = mSurface->w;
         size->mY = mSurface->h;
-        return (true);
+        return true;
     }
 
-    return (false);
+    return false;
 }
 
 bool LLWindowSDL::setPosition(const LLCoordScreen position)
@@ -737,7 +836,6 @@ template< typename T > bool setSizeImpl( const T& newSize, SDL_Window *pWin )
     if( nFlags & SDL_WINDOW_MAXIMIZED )
         SDL_RestoreWindow( pWin );
 
-
     SDL_SetWindowSize( pWin, newSize.mX, newSize.mY );
     SDL_Event event;
     event.type = SDL_WINDOWEVENT;
@@ -803,7 +901,8 @@ bool LLWindowSDL::setGamma(const F32 gamma)
         Uint16 ramp[256];
 
         mGamma = gamma;
-        if (mGamma == 0) mGamma = 0.1f;
+        if (mGamma == 0)
+            mGamma = 0.1f;
         mGamma = 1.f / mGamma;
 
         SDL_CalculateGammaRamp(mGamma, ramp);
@@ -820,7 +919,8 @@ bool LLWindowSDL::isCursorHidden()
 // Constrains the mouse to the window.
 void LLWindowSDL::setMouseClipping(bool b)
 {
-    //SDL_WM_GrabInput(b ? SDL_GRAB_ON : SDL_GRAB_OFF);
+    if( mWindow )
+        SDL_SetWindowGrab( mWindow, b?SDL_TRUE:SDL_FALSE );
 }
 
 // virtual
@@ -840,17 +940,11 @@ bool LLWindowSDL::setCursorPosition(const LLCoordWindow position)
     LLCoordScreen screen_pos;
 
     if (!convertCoords(position, &screen_pos))
-    {
         return false;
-    }
-
-    //LL_INFOS() << "setCursorPosition(" << screen_pos.mX << ", " << screen_pos.mY << ")" << LL_ENDL;
 
     // do the actual forced cursor move.
     SDL_WarpMouseInWindow(mWindow, screen_pos.mX, screen_pos.mY);
 
-    //LL_INFOS() << llformat("llcw %d,%d -> scr %d,%d", position.mX, position.mY, screen_pos.mX, screen_pos.mY) << LL_ENDL;
-
     return result;
 }
 
@@ -868,7 +962,6 @@ bool LLWindowSDL::getCursorPosition(LLCoordWindow *position)
     return convertCoords(screen_pos, position);
 }
 
-
 F32 LLWindowSDL::getNativeAspectRatio()
 {
     // MBW -- there are a couple of bad assumptions here.  One is that the display list won't include
@@ -889,9 +982,7 @@ F32 LLWindowSDL::getNativeAspectRatio()
     // switching, and stashes it in mOriginalAspectRatio.  Here, we just return it.
 
     if (mOverrideAspectRatio > 0.f)
-    {
         return mOverrideAspectRatio;
-    }
 
     return mOriginalAspectRatio;
 }
@@ -903,9 +994,7 @@ F32 LLWindowSDL::getPixelAspectRatio()
     {
         LLCoordScreen screen_size;
         if (getSize(&screen_size))
-        {
             pixel_aspect = getNativeAspectRatio() * (F32)screen_size.mY / (F32)screen_size.mX;
-        }
     }
 
     return pixel_aspect;
@@ -916,61 +1005,34 @@ F32 LLWindowSDL::getPixelAspectRatio()
 // dialogs are still usable in fullscreen.
 void LLWindowSDL::beforeDialog()
 {
-    bool running_x11 = false;
-#if LL_X11
-    running_x11 = (mSDL_XWindowID != None);
-#endif //LL_X11
-
     LL_INFOS() << "LLWindowSDL::beforeDialog()" << LL_ENDL;
 
     if (SDLReallyCaptureInput(false)) // must ungrab input so popup works!
     {
-        if (mFullscreen)
-        {
-            // need to temporarily go non-fullscreen; bless SDL
-            // for providing a SDL_WM_ToggleFullScreen() - though
-            // it only works in X11
-            if (running_x11 && mWindow)
-            {
-                SDL_SetWindowFullscreen( mWindow, 0 );
-            }
-        }
+        if (mFullscreen && mWindow )
+            SDL_SetWindowFullscreen( mWindow, 0 );
     }
 
-#if LL_X11
-    if (mSDL_Display)
+    if (mServerProtocol == X11 && mX11Data.mDisplay)
     {
         // Everything that we/SDL asked for should happen before we
         // potentially hand control over to GTK.
         maybe_lock_display();
-        XSync(mSDL_Display, False);
+        XSync(mX11Data.mDisplay, False);
         maybe_unlock_display();
     }
-#endif // LL_X11
 
     maybe_lock_display();
 }
 
 void LLWindowSDL::afterDialog()
 {
-    bool running_x11 = false;
-#if LL_X11
-    running_x11 = (mSDL_XWindowID != None);
-#endif //LL_X11
-
     LL_INFOS() << "LLWindowSDL::afterDialog()" << LL_ENDL;
 
     maybe_unlock_display();
 
-    if (mFullscreen)
-    {
-        // need to restore fullscreen mode after dialog - only works
-        // in X11
-        if (running_x11 && mWindow)
-        {
-            SDL_SetWindowFullscreen( mWindow, 0 );
-        }
-    }
+    if (mFullscreen && mWindow )
+        SDL_SetWindowFullscreen( mWindow, 0 );
 }
 
 void LLWindowSDL::flashIcon(F32 seconds)
@@ -987,6 +1049,15 @@ void LLWindowSDL::flashIcon(F32 seconds)
     mFlashing = true;
 }
 
+void LLWindowSDL::maybeStopFlashIcon()
+{
+    if (mFlashing && mFlashTimer.hasExpired())
+    {
+        mFlashing = false;
+        SDL_FlashWindow( mWindow, SDL_FLASH_CANCEL );
+    }
+}
+
 bool LLWindowSDL::isClipboardTextAvailable()
 {
     return SDL_HasClipboardText() == SDL_TRUE;
@@ -1054,9 +1125,7 @@ LLWindow::LLWindowResolution* LLWindowSDL::getSupportedResolutions(S32 &num_reso
         {
             SDL_DisplayMode mode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
             if (SDL_GetDisplayMode( 0 , i, &mode) != 0)
-            {
                 continue;
-            }
 
             int w = mode.w;
             int h = mode.h;
@@ -1109,7 +1178,7 @@ bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordWindow* to) const
     // In the fullscreen case, window and screen coordinates are the same.
     to->mX = from.mX;
     to->mY = from.mY;
-    return (true);
+    return true;
 }
 
 bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordScreen *to) const
@@ -1120,21 +1189,21 @@ bool LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordScreen *to) const
     // In the fullscreen case, window and screen coordinates are the same.
     to->mX = from.mX;
     to->mY = from.mY;
-    return (true);
+    return true;
 }
 
 bool LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordGL *to) const
 {
     LLCoordWindow window_coord;
 
-    return(convertCoords(from, &window_coord) && convertCoords(window_coord, to));
+    return convertCoords(from, &window_coord) && convertCoords(window_coord, to);
 }
 
 bool LLWindowSDL::convertCoords(LLCoordGL from, LLCoordScreen *to) const
 {
     LLCoordWindow window_coord;
 
-    return(convertCoords(from, &window_coord) && convertCoords(window_coord, to));
+    return convertCoords(from, &window_coord) && convertCoords(window_coord, to);
 }
 
 void LLWindowSDL::setupFailure(const std::string& text, const std::string& caption, U32 type)
@@ -1142,55 +1211,17 @@ void LLWindowSDL::setupFailure(const std::string& text, const std::string& capti
     destroyContext();
 
     OSMessageBox(text, caption, type);
+
+    // This is so catastrophic > bail as fast as possible. Otherwise the viewer can be stuck in a perpetual state of startup pain
+    std::terminate();
 }
 
 bool LLWindowSDL::SDLReallyCaptureInput(bool capture)
 {
-    // note: this used to be safe to call nestedly, but in the
-    // end that's not really a wise usage pattern, so don't.
-
-    if (capture)
-        mReallyCapturedCount = 1;
-    else
-        mReallyCapturedCount = 0;
-
-    bool wantGrab;
-    if (mReallyCapturedCount <= 0) // uncapture
-    {
-        wantGrab = false;
-    } else // capture
-    {
-        wantGrab = true;
-    }
-
-    if (mReallyCapturedCount < 0) // yuck, imbalance.
-    {
-        mReallyCapturedCount = 0;
-        LL_WARNS() << "ReallyCapture count was < 0" << LL_ENDL;
-    }
+    if (!mFullscreen && mWindow ) /* only bother if we're windowed anyway */
+        SDL_SetWindowGrab( mWindow, capture?SDL_TRUE:SDL_FALSE);
 
-    bool newGrab = wantGrab;
-
-    if (!mFullscreen) /* only bother if we're windowed anyway */
-    {
-        int result;
-        if (wantGrab == true)
-        {
-            result = SDL_CaptureMouse(SDL_TRUE);
-            if (0 == result)
-                newGrab = true;
-            else
-                newGrab = false;
-        }
-        else
-        {
-            newGrab = false;
-            result = SDL_CaptureMouse(SDL_FALSE);
-        }
-    }
-
-    // return boolean success for whether we ended up in the desired state
-    return capture == newGrab;
+    return capture;
 }
 
 U32 LLWindowSDL::SDLCheckGrabbyKeys(U32 keysym, bool gain)
@@ -1237,7 +1268,6 @@ U32 LLWindowSDL::SDLCheckGrabbyKeys(U32 keysym, bool gain)
 
 void check_vm_bloat()
 {
-#if LL_LINUX
     // watch our own VM and RSS sizes, warn if we bloated rapidly
     static const std::string STATS_FILE = "/proc/self/stat";
     FILE *fp = fopen(STATS_FILE.c_str(), "r");
@@ -1252,7 +1282,7 @@ void check_vm_bloat()
 
         ssize_t res;
         size_t dummy;
-        char *ptr = NULL;
+        char *ptr = nullptr;
         for (int i=0; i<22; ++i) // parse past the values we don't want
         {
             res = getdelim(&ptr, &dummy, ' ', fp);
@@ -1262,7 +1292,7 @@ void check_vm_bloat()
                 goto finally;
             }
             free(ptr);
-            ptr = NULL;
+            ptr = nullptr;
         }
         // 23rd space-delimited entry is vsize
         res = getdelim(&ptr, &dummy, ' ', fp);
@@ -1274,7 +1304,7 @@ void check_vm_bloat()
         }
         this_vm_size = atoll(ptr);
         free(ptr);
-        ptr = NULL;
+        ptr = nullptr;
         // 24th space-delimited entry is RSS
         res = getdelim(&ptr, &dummy, ' ', fp);
         llassert(ptr);
@@ -1285,12 +1315,11 @@ void check_vm_bloat()
         }
         this_rss_size = getpagesize() * atoll(ptr);
         free(ptr);
-        ptr = NULL;
+        ptr = nullptr;
 
         LL_INFOS() << "VM SIZE IS NOW " << (this_vm_size/(1024*1024)) << " MB, RSS SIZE IS NOW " << (this_rss_size/(1024*1024)) << " MB" << LL_ENDL;
 
-        if (llabs(last_vm_size - this_vm_size) >
-            significant_vm_difference)
+        if (llabs(last_vm_size - this_vm_size) > significant_vm_difference)
         {
             if (this_vm_size > last_vm_size)
             {
@@ -1302,8 +1331,7 @@ void check_vm_bloat()
             }
         }
 
-        if (llabs(last_rss_size - this_rss_size) >
-            significant_rss_difference)
+        if (llabs(last_rss_size - this_rss_size) > significant_rss_difference)
         {
             if (this_rss_size > last_rss_size)
             {
@@ -1319,21 +1347,16 @@ void check_vm_bloat()
         last_vm_size = this_vm_size;
 
 finally:
-        if (NULL != ptr)
-        {
+        if (ptr)
             free(ptr);
-            ptr = NULL;
-        }
         fclose(fp);
     }
-#endif // LL_LINUX
 }
 
 
 // virtual
 void LLWindowSDL::processMiscNativeEvents()
 {
-#if LL_GLIB
     // Pump until we've nothing left to do or passed 1/15th of a
     // second pumping for this frame.
     static LLTimer pump_timer;
@@ -1343,13 +1366,10 @@ void LLWindowSDL::processMiscNativeEvents()
     {
         g_main_context_iteration(g_main_context_default(), false);
     } while( g_main_context_pending(g_main_context_default()) && !pump_timer.hasExpired());
-#endif
 
     // hack - doesn't belong here - but this is just for debugging
     if (getenv("LL_DEBUG_BLOAT"))
-    {
         check_vm_bloat();
-    }
 }
 
 void LLWindowSDL::gatherInput(bool app_has_focus)
@@ -1388,7 +1408,7 @@ void LLWindowSDL::gatherInput(bool app_has_focus)
             {
                 auto string = utf8str_to_utf16str( event.text.text );
                 mKeyModifiers = gKeyboard->currentMask( false );
-                mInputType = "textinput";
+
                 for( auto key: string )
                 {
                     mKeyVirtualKey = key;
@@ -1404,13 +1424,10 @@ void LLWindowSDL::gatherInput(bool app_has_focus)
             case SDL_KEYDOWN:
                 mKeyVirtualKey = event.key.keysym.sym;
                 mKeyModifiers = event.key.keysym.mod;
-                mInputType = "keydown";
 
                 // treat all possible Enter/Return keys the same
                 if (mKeyVirtualKey == SDLK_RETURN2 || mKeyVirtualKey == SDLK_KP_ENTER)
-                {
                     mKeyVirtualKey = SDLK_RETURN;
-                }
 
                 gKeyboard->handleKeyDown(mKeyVirtualKey, mKeyModifiers );
 
@@ -1433,13 +1450,10 @@ void LLWindowSDL::gatherInput(bool app_has_focus)
             case SDL_KEYUP:
                 mKeyVirtualKey = event.key.keysym.sym;
                 mKeyModifiers = event.key.keysym.mod;
-                mInputType = "keyup";
 
                 // treat all possible Enter/Return keys the same
                 if (mKeyVirtualKey == SDLK_RETURN2 || mKeyVirtualKey == SDLK_KP_ENTER)
-                {
                     mKeyVirtualKey = SDLK_RETURN;
-                }
 
                 if (SDLCheckGrabbyKeys(mKeyVirtualKey, false) == 0)
                     SDLReallyCaptureInput(false); // part of the fix for SL-13243
@@ -1461,7 +1475,7 @@ void LLWindowSDL::gatherInput(bool app_has_focus)
                     else
                         mCallbacks->handleMouseDown(this, openGlCoord, mask);
                 }
-                else if (event.button.button == SDL_BUTTON_RIGHT)  // right
+                else if (event.button.button == SDL_BUTTON_RIGHT)
                 {
                     mCallbacks->handleRightMouseDown(this, openGlCoord, mask);
                 }
@@ -1591,12 +1605,12 @@ static SDL_Cursor *makeSDLCursorFromBMP(const char *filename, int hotx, int hoty
                                            SDL_SwapLE32(0xFF00U),
                                            SDL_SwapLE32(0xFF0000U),
                                            SDL_SwapLE32(0xFF000000U));
-        SDL_FillRect(cursurface, NULL, SDL_SwapLE32(0x00000000U));
+        SDL_FillRect(cursurface, nullptr, SDL_SwapLE32(0x00000000U));
 
         // Blit the cursor pixel data onto a 32-bit RGBA surface so we
         // only have to cope with processing one type of pixel format.
-        if (0 == SDL_BlitSurface(bmpsurface, NULL,
-                                 cursurface, NULL))
+        if (0 == SDL_BlitSurface(bmpsurface, nullptr,
+                                 cursurface, nullptr))
         {
             // n.b. we already checked that width is a multiple of 8.
             const int bitmap_bytes = (cursurface->w * cursurface->h) / 8;
@@ -1670,12 +1684,10 @@ void LLWindowSDL::updateCursor()
 
 void LLWindowSDL::initCursors()
 {
-    int i;
     // Blank the cursor pointer array for those we may miss.
-    for (i=0; i<UI_CURSOR_COUNT; ++i)
-    {
+    for ( int i=0; i<UI_CURSOR_COUNT; ++i)
         mSDLCursors[i] = nullptr;
-    }
+
     // Pre-make an SDL cursor for each of the known cursor types.
     // We hardcode the hotspots - to avoid that we'd have to write
     // a .cur file loader.
@@ -1728,23 +1740,24 @@ void LLWindowSDL::initCursors()
 
 void LLWindowSDL::quitCursors()
 {
-    int i;
     if (mWindow)
     {
-        for (i=0; i<UI_CURSOR_COUNT; ++i)
+        for (int i=0; i<UI_CURSOR_COUNT; ++i)
         {
             if (mSDLCursors[i])
             {
                 SDL_FreeCursor(mSDLCursors[i]);
-                mSDLCursors[i] = NULL;
+                mSDLCursors[i] = nullptr;
             }
         }
-    } else {
+    }
+    else
+    {
         // SDL doesn't refcount cursors, so if the window has
         // already been destroyed then the cursors have gone with it.
         LL_INFOS() << "Skipping quitCursors: mWindow already gone." << LL_ENDL;
-        for (i=0; i<UI_CURSOR_COUNT; ++i)
-            mSDLCursors[i] = NULL;
+        for (int i=0; i<UI_CURSOR_COUNT; ++i)
+            mSDLCursors[i] = nullptr;
     }
 }
 
@@ -1872,7 +1885,7 @@ S32 OSMessageBoxSDL(const std::string& text, const std::string& caption, U32 typ
 
 bool LLWindowSDL::dialogColorPicker( F32 *r, F32 *g, F32 *b)
 {
-    return (false);
+    return false;
 }
 
 /*
@@ -1902,7 +1915,6 @@ LLSD LLWindowSDL::getNativeKeyData() const
     result["virtual_key"] = (S32)mKeyVirtualKey;
     result["virtual_key_win"] = (S32)LLKeyboardSDL::mapSDL2toWin( mKeyVirtualKey );
     result["modifiers"] = (S32)modifiers;
-    result["input_type"] = mInputType;
     return result;
 }
 
@@ -1939,7 +1951,7 @@ void LLWindowSDL::spawnWebBrowser(const std::string& escaped_url, bool async)
 
 void *LLWindowSDL::getPlatformWindow()
 {
-    return NULL;
+    return nullptr;
 }
 
 void LLWindowSDL::bringToFront()
@@ -1973,8 +1985,8 @@ std::vector<std::string> LLWindowSDL::getDynamicFallbackFontList()
     // to use some of the fonts we want it to.
     const bool elide_unicode_coverage = true;
     std::vector<std::string> rtns;
-    FcFontSet *fs = NULL;
-    FcPattern *sortpat = NULL;
+    FcFontSet *fs = nullptr;
+    FcPattern *sortpat = nullptr;
 
     LL_INFOS() << "Getting system font list from FontConfig..." << LL_ENDL;
 
@@ -1983,7 +1995,7 @@ std::vector<std::string> LLWindowSDL::getDynamicFallbackFontList()
     // of languages that can be displayed, but ensures that their
     // preferred language is rendered from a single consistent font where
     // possible.
-    FL_Locale *locale = NULL;
+    FL_Locale *locale = nullptr;
     FL_Success success = FL_FindLocale(&locale, FL_MESSAGES);
     if (success != 0)
     {
@@ -2014,8 +2026,7 @@ std::vector<std::string> LLWindowSDL::getDynamicFallbackFontList()
     {
         // Sort the list of system fonts from most-to-least-desirable.
         FcResult result;
-        fs = FcFontSort(NULL, sortpat, elide_unicode_coverage,
-                        NULL, &result);
+        fs = FcFontSort(nullptr, sortpat, elide_unicode_coverage, nullptr, &result);
         FcPatternDestroy(sortpat);
     }
 
@@ -2028,10 +2039,7 @@ std::vector<std::string> LLWindowSDL::getDynamicFallbackFontList()
         for (int i=0; i<fs->nfont; ++i)
         {
             FcChar8 *filename;
-            if (FcResultMatch == FcPatternGetString(fs->fonts[i],
-                                                    FC_FILE, 0,
-                                                    &filename)
-                && filename)
+            if (FcResultMatch == FcPatternGetString(fs->fonts[i], FC_FILE, 0, &filename) && filename)
             {
                 rtns.push_back(std::string((const char*)filename));
                 if (rtns.size() >= max_font_count_cutoff)
@@ -2042,12 +2050,11 @@ std::vector<std::string> LLWindowSDL::getDynamicFallbackFontList()
     }
 
     LL_DEBUGS() << "Using font list: " << LL_ENDL;
-    for (std::vector<std::string>::iterator it = rtns.begin();
-         it != rtns.end();
-         ++it)
+    for (auto it = rtns.begin(); it != rtns.end(); ++it)
     {
         LL_DEBUGS() << "  file: " << *it << LL_ENDL;
     }
+
     LL_INFOS() << "Using " << rtns.size() << "/" << found_font_count << " system fonts." << LL_ENDL;
 
     rtns.push_back(final_fallback);
diff --git a/indra/llwindow/llwindowsdl.h b/indra/llwindow/llwindowsdl.h
index a85b7c11e7..974ba69b61 100644
--- a/indra/llwindow/llwindowsdl.h
+++ b/indra/llwindow/llwindowsdl.h
@@ -11,7 +11,6 @@
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
  *
- * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
@@ -36,10 +35,8 @@
 #include "SDL2/SDL.h"
 #include "SDL2/SDL_endian.h"
 
-#if LL_X11
 // get X11-specific headers for use in low-level stuff like copy-and-paste support
 #include "SDL2/SDL_syswm.h"
-#endif
 
 // AssertMacros.h does bad things.
 #include "fix_macros.h"
@@ -50,8 +47,8 @@
 class LLWindowSDL : public LLWindow {
 public:
     void show() override;
-
     void hide() override;
+    void restore() override;
 
     void close() override;
 
@@ -62,11 +59,8 @@ public:
     bool getMaximized() const override;
 
     bool maximize() override;
-
     void minimize() override;
 
-    void restore() override;
-
     bool getPosition(LLCoordScreen *position) const override;
 
     bool getSize(LLCoordScreen *size) const override;
@@ -87,49 +81,38 @@ public:
     bool getCursorPosition(LLCoordWindow *position) override;
 
     void showCursor() override;
-
     void hideCursor() override;
+    bool isCursorHidden() override;
 
     void showCursorFromMouseMove() override;
-
     void hideCursorUntilMouseMove() override;
 
-    bool isCursorHidden() override;
-
     void updateCursor() override;
 
     void captureMouse() override;
-
     void releaseMouse() override;
 
     void setMouseClipping(bool b) override;
 
-       void setMinSize(U32 min_width, U32 min_height, bool enforce_immediately = true) override;
+    void setMinSize(U32 min_width, U32 min_height, bool enforce_immediately = true) override;
 
     bool isClipboardTextAvailable() override;
-
     bool pasteTextFromClipboard(LLWString &dst) override;
-
     bool copyTextToClipboard(const LLWString &src) override;
-
     bool isPrimaryTextAvailable() override;
-
     bool pasteTextFromPrimary(LLWString &dst) override;
-
     bool copyTextToPrimary(const LLWString &src) override;
 
     void flashIcon(F32 seconds) override;
+    void maybeStopFlashIcon();
 
     F32 getGamma() const override;
-
     bool setGamma(const F32 gamma) override; // Set the gamma
+    bool restoreGamma() override;            // Restore original gamma table (before updating gamma)
 
     U32 getFSAASamples() const override;
-
     void setFSAASamples(const U32 samples) override;
 
-    bool restoreGamma() override;            // Restore original gamma table (before updating gamma)
-
     void processMiscNativeEvents() override;
 
     void gatherInput(bool app_has_focus) override;
@@ -162,7 +145,6 @@ public:
     void setNativeAspectRatio(F32 ratio)  override { mOverrideAspectRatio = ratio; }
 
     void beforeDialog() override;
-
     void afterDialog() override;
 
     bool dialogColorPicker(F32 *r, F32 *g, F32 *b) override;
@@ -179,31 +161,15 @@ public:
 
     static std::vector<std::string> getDynamicFallbackFontList();
 
-    // Not great that these are public, but they have to be accessible
-    // by non-class code and it's better than making them global.
-#if LL_X11
-    Window mSDL_XWindowID;
-    Display *mSDL_Display;
-#endif
-
-    void (*Lock_Display)(void);
-
-    void (*Unlock_Display)(void);
-
-#if LL_X11
+    void (*Lock_Display)(void) = nullptr;
+    void (*Unlock_Display)(void) = nullptr;
 
     static Window get_SDL_XWindowID(void);
-
     static Display *get_SDL_Display(void);
 
-#endif // LL_X11
-
     void *createSharedContext() override;
-
     void makeContextCurrent(void *context) override;
-
     void destroySharedContext(void *context) override;
-
     void toggleVSync(bool enable_vsync) override;
 
 protected:
@@ -219,7 +185,6 @@ protected:
     LLSD getNativeKeyData() const override;
 
     void initCursors();
-
     void quitCursors();
 
     void moveWindow(const LLCoordScreen &position, const LLCoordScreen &size);
@@ -239,7 +204,6 @@ protected:
 
     // create or re-create the GL context/window.  Called from the constructor and switchContext().
     bool createContext(int x, int y, int width, int height, int bits, bool fullscreen, bool enable_vsync);
-
     void destroyContext();
 
     void setupFailure(const std::string &text, const std::string &caption, U32 type);
@@ -251,36 +215,50 @@ protected:
     //
     // Platform specific variables
     //
-    U32 mGrabbyKeyFlags;
-    int mReallyCapturedCount;
+    U32 mGrabbyKeyFlags = 0;
 
-    SDL_Window *mWindow;
+    SDL_Window *mWindow = nullptr;
     SDL_Surface *mSurface;
     SDL_GLContext mContext;
     SDL_Cursor *mSDLCursors[UI_CURSOR_COUNT];
 
     std::string mWindowTitle;
-    double mOriginalAspectRatio;
-    bool mNeedsResize;        // Constructor figured out the window is too big, it needs a resize.
+    double mOriginalAspectRatio = 1.0f;
+    bool mNeedsResize = false;        // Constructor figured out the window is too big, it needs a resize.
     LLCoordScreen mNeedsResizeSize;
-    F32 mOverrideAspectRatio;
-    F32 mGamma;
-    U32 mFSAASamples;
+    F32 mOverrideAspectRatio = 0.0f;
+    F32 mGamma = 0.0f;
+    U32 mFSAASamples = 0;
 
-    int mSDLFlags;
-
-    int mHaveInputFocus; /* 0=no, 1=yes, else unknown */
-    int mIsMinimized; /* 0=no, 1=yes, else unknown */
+    int mHaveInputFocus = -1; /* 0=no, 1=yes, else unknown */
 
     friend class LLWindowManager;
 
 private:
-    bool mFlashing;
+    bool mFlashing = false;
     LLTimer mFlashTimer;
-    U32 mKeyVirtualKey;
-    U32 mKeyModifiers;
-    std::string mInputType;
+    U32 mKeyVirtualKey = 0;
+    U32 mKeyModifiers = KMOD_NONE;
+
+    enum EServerProtocol{ X11, Wayland, Unknown };
+    EServerProtocol mServerProtocol = Unknown;
 
+    struct {
+        Window mXWindowID = None;
+        Display *mDisplay = nullptr;
+    } mX11Data;
+
+    // Wayland
+    struct {
+        wl_surface *mSurface = nullptr;
+        uint64_t mLastFrameEvent = 0;
+    } mWaylandData;
+
+    bool isWaylandWindowNotDrawing() const;
+
+    void setupWaylandFrameCallback();
+    static void waylandFrameDoneCB(void *data, struct wl_callback *cb, uint32_t time);
+    //
 
 private:
     void tryFindFullscreenSize(int &aWidth, int &aHeight);
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index f8294f063f..f349c4aea8 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -403,6 +403,7 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
     // until after some graphics setup. See SL-20177. -Cosmic,2023-09-18
     bool mGLReady = false;
     bool mGotGLBuffer = false;
+    bool mShuttingDown = false;
 };
 
 
@@ -4576,14 +4577,14 @@ inline LLWindowWin32::LLWindowWin32Thread::LLWindowWin32Thread()
 
 void LLWindowWin32::LLWindowWin32Thread::close()
 {
-    if (!mQueue->isClosed())
+    LL::ThreadPool::close();
+    if (!mShuttingDown)
     {
         LL_WARNS() << "Closing window thread without using destroy_window_handler" << LL_ENDL;
-        LL::ThreadPool::close();
-
         // Workaround for SL-18721 in case window closes too early and abruptly
         LLSplashScreen::show();
         LLSplashScreen::update("..."); // will be updated later
+        mShuttingDown = true;
     }
 }
 
@@ -4795,6 +4796,8 @@ void LLWindowWin32::LLWindowWin32Thread::wakeAndDestroy()
         return;
     }
 
+    mShuttingDown = true;
+
     // Make sure we don't leave a blank toolbar button.
     // Also hiding window now prevents user from suspending it
     // via some action (like dragging it around)
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 6c8d7b910e..3bf01d252d 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -734,6 +734,11 @@ set(viewer_SOURCE_FILES
     llxmlrpctransaction.cpp
     noise.cpp
     pipeline.cpp
+    rlvactions.cpp
+    rlvcommon.cpp
+    rlvfloaters.cpp
+    rlvhelper.cpp
+    rlvhandler.cpp
     )
 
 set(VIEWER_BINARY_NAME "secondlife-bin" CACHE STRING
@@ -1399,6 +1404,12 @@ set(viewer_HEADER_FILES
     llxmlrpctransaction.h
     noise.h
     pipeline.h
+    rlvdefines.h
+    rlvactions.h
+    rlvcommon.h
+    rlvfloaters.h
+    rlvhelper.h
+    rlvhandler.h
     roles_constants.h
     VertexCache.h
     VorbisFramework.h
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index d58ff17aaa..c086399375 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -2469,6 +2469,17 @@
       <key>Value</key>
       <integer>1</integer>
     </map>
+    <key>UseGroupMemberPagination</key>
+    <map>
+      <key>Comment</key>
+      <string>Enable pagination of group memeber list 50 members at a time.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
     <key>DisplayTimecode</key>
     <map>
       <key>Comment</key>
@@ -4122,6 +4133,17 @@
       <key>Value</key>
       <array />
     </map>
+    <key>LuaDebugShowSource</key>
+    <map>
+      <key>Comment</key>
+      <string>Show source info in Lua Debug Console output</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
     <key>GridStatusRSS</key>
     <map>
       <key>Comment</key>
@@ -4630,6 +4652,17 @@
       <key>Value</key>
       <integer>1</integer>
     </map>
+    <key>MapShowGridCoords</key>
+    <map>
+      <key>Comment</key>
+      <string>Shows/hides the grid coordinates of each region on the world map.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
     <key>MiniMapAutoCenter</key>
     <map>
       <key>Comment</key>
@@ -10102,6 +10135,83 @@
             <key>Value</key>
             <string>https://feedback.secondlife.com/</string>
         </map>
+    <key>RestrainedLove</key>
+    <map>
+      <key>Comment</key>
+      <string>Toggles RLVa features (requires restart)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>0</boolean>
+    </map>
+    <key>RestrainedLoveDebug</key>
+    <map>
+      <key>Comment</key>
+      <string>Toggles RLVa debug mode (displays the commands when in debug mode)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>0</boolean>
+    </map>
+    <key>RLVaBlockedExperiences</key>
+    <map>
+      <key>Comment</key>
+      <string>List of experiences blocked from interacting with RLVa</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string>bfe25fb4-222c-11e5-85a2-fa4c4ccaa202</string>
+    </map>
+    <key>RLVaDebugHideUnsetDuplicate</key>
+    <map>
+      <key>Comment</key>
+      <string>Suppresses reporting "unset" or "duplicate" command restrictions when RestrainedLoveDebug is TRUE</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>0</boolean>
+    </map>
+    <key>RLVaEnableTemporaryAttachments</key>
+    <map>
+      <key>Comment</key>
+      <string>Allows temporary attachments (regardless of origin) to issue RLV commands</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>1</boolean>
+    </map>
+    <key>RLVaExperimentalCommands</key>
+    <map>
+      <key>Comment</key>
+      <string>Enables the experimental command set</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>1</boolean>
+    </map>
+    <key>RLVaTopLevelMenu</key>
+    <map>
+      <key>Comment</key>
+      <string>Show the RLVa specific menu as a top level menu</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>1</boolean>
+    </map>
     <key>RevokePermsOnStopAnimation</key>
     <map>
       <key>Comment</key>
@@ -12989,9 +13099,9 @@
     <key>Use24HourClock</key>
     <map>
         <key>Comment</key>
-        <string>12 vs 24. At the moment only for region restart schedule floater</string>
+        <string>12 vs 24. At the moment coverage is partial</string>
         <key>Persist</key>
-        <integer>0</integer>
+        <integer>1</integer>
         <key>Type</key>
         <string>Boolean</string>
         <key>Value</key>
@@ -13646,7 +13756,7 @@
       <key>Type</key>
       <string>Boolean</string>
       <key>Value</key>
-      <integer>0</integer>
+      <integer>1</integer>
     </map>
     <key>WarningsAsChat</key>
     <map>
@@ -15290,7 +15400,7 @@
       <key>Type</key>
       <string>U32</string>
       <key>Value</key>
-      <integer>5</integer>
+      <integer>8</integer>
     </map>
     <key>TerrainPaintResolution</key>
     <map>
diff --git a/indra/newview/app_settings/shaders/class1/interface/pbrTerrainBakeF.glsl b/indra/newview/app_settings/shaders/class1/interface/pbrTerrainBakeF.glsl
index cf20653a0f..a79a56d725 100644
--- a/indra/newview/app_settings/shaders/class1/interface/pbrTerrainBakeF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/pbrTerrainBakeF.glsl
@@ -1,5 +1,5 @@
 /**
- * @file terrainBakeF.glsl
+ * @file pbrTerrainBakeF.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
diff --git a/indra/newview/app_settings/shaders/class1/interface/terrainStampF.glsl b/indra/newview/app_settings/shaders/class1/interface/terrainStampF.glsl
new file mode 100644
index 0000000000..e79e9010e6
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/interface/terrainStampF.glsl
@@ -0,0 +1,44 @@
+/**
+ * @file terrainStampF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+out vec4 frag_color;
+
+// Paint texture to stamp into the "paintmap"
+uniform sampler2D diffuseMap;
+
+in vec2 vary_texcoord0;
+
+void main()
+{
+    vec4 col = texture(diffuseMap, vary_texcoord0);
+    if (col.a <= 0.0f)
+    {
+        discard;
+    }
+
+    frag_color = max(col, vec4(0));
+}
diff --git a/indra/newview/app_settings/shaders/class1/interface/terrainStampV.glsl b/indra/newview/app_settings/shaders/class1/interface/terrainStampV.glsl
new file mode 100644
index 0000000000..294fa6be26
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/interface/terrainStampV.glsl
@@ -0,0 +1,39 @@
+/**
+ * @file terrainStampV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+uniform mat4 modelview_projection_matrix;
+uniform vec2 terrain_stamp_scale;
+
+in vec3 position;
+
+out vec2 vary_texcoord0;
+
+void main()
+{
+    gl_Position = modelview_projection_matrix * vec4(position, 1.0);
+    // Positions without transforms are treated as UVs for the purpose of this shader.
+    vary_texcoord0.xy = terrain_stamp_scale * position.xy;
+}
+
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index ca35608175..3d4f5e1054 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -355,20 +355,6 @@ bool LLAgent::isMicrophoneOn(const LLSD& sdname)
     return LLVoiceClient::getInstance()->getUserPTTState();
 }
 
-//static
-void LLAgent::toggleHearMediaSoundFromAvatar()
-{
-    const S32 mediaSoundsEarLocation = gSavedSettings.getS32("MediaSoundsEarLocation");
-    gSavedSettings.setS32("MediaSoundsEarLocation", !mediaSoundsEarLocation);
-}
-
-//static
-void LLAgent::toggleHearVoiceFromAvatar()
-{
-    const S32 voiceEarLocation = gSavedSettings.getS32("VoiceEarLocation");
-    gSavedSettings.setS32("VoiceEarLocation", !voiceEarLocation);
-}
-
 // ************************************************************
 // Enabled this definition to compile a 'hacked' viewer that
 // locally believes the end user has godlike powers.
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index 448ee575f5..489131d974 100644
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -377,13 +377,6 @@ private:
     bool            mVoiceConnected;
 
     //--------------------------------------------------------------------
-    // Sound
-    //--------------------------------------------------------------------
-public:
-    static void     toggleHearMediaSoundFromAvatar();
-    static void     toggleHearVoiceFromAvatar();
-
-    //--------------------------------------------------------------------
     // Chat
     //--------------------------------------------------------------------
 public:
diff --git a/indra/newview/llagentlistener.cpp b/indra/newview/llagentlistener.cpp
index 14e443ec4e..6c539ade9b 100644
--- a/indra/newview/llagentlistener.cpp
+++ b/indra/newview/llagentlistener.cpp
@@ -32,11 +32,14 @@
 
 #include "llagent.h"
 #include "llagentcamera.h"
+#include "llavatarname.h"
+#include "llavatarnamecache.h"
 #include "llvoavatar.h"
 #include "llcommandhandler.h"
 #include "llinventorymodel.h"
 #include "llslurl.h"
 #include "llurldispatcher.h"
+#include "llviewercontrol.h"
 #include "llviewernetwork.h"
 #include "llviewerobject.h"
 #include "llviewerobjectlist.h"
@@ -46,7 +49,8 @@
 #include "llsdutil_math.h"
 #include "lltoolgrab.h"
 #include "llhudeffectlookat.h"
-#include "llagentcamera.h"
+#include "llviewercamera.h"
+#include "resultset.h"
 #include <functional>
 
 static const F64 PLAY_ANIM_THROTTLE_PERIOD = 1.f;
@@ -176,6 +180,32 @@ LLAgentListener::LLAgentListener(LLAgent &agent)
         "Return information about [\"item_id\"] animation",
         &LLAgentListener::getAnimationInfo,
         llsd::map("item_id", LLSD(), "reply", LLSD()));
+
+    add("getID",
+        "Return your own avatar ID",
+        &LLAgentListener::getID,
+        llsd::map("reply", LLSD()));
+
+    add("getNearbyAvatarsList",
+        "Return result set key [\"result\"] for nearby avatars in a range of [\"dist\"]\n"
+        "if [\"dist\"] is not specified, 'RenderFarClip' setting is used\n"
+        "reply contains \"result\" table with \"id\", \"name\", \"global_pos\", \"region_pos\", \"region_id\" fields",
+        &LLAgentListener::getNearbyAvatarsList,
+        llsd::map("reply", LLSD()));
+
+    add("getNearbyObjectsList",
+        "Return result set key [\"result\"] for nearby objects in a range of [\"dist\"]\n"
+        "if [\"dist\"] is not specified, 'RenderFarClip' setting is used\n"
+        "reply contains \"result\" table with \"id\", \"global_pos\", \"region_pos\", \"region_id\" fields",
+        &LLAgentListener::getNearbyObjectsList,
+        llsd::map("reply", LLSD()));
+
+    add("getAgentScreenPos",
+        "Return screen position of the [\"avatar_id\"] avatar or own avatar if not specified\n"
+        "reply contains \"x\", \"y\" coordinates and \"onscreen\" flag to indicate if it's actually in within the current window\n"
+        "avatar render position is used as the point",
+        &LLAgentListener::getAgentScreenPos,
+        llsd::map("reply", LLSD()));
 }
 
 void LLAgentListener::requestTeleport(LLSD const & event_data) const
@@ -693,3 +723,126 @@ void LLAgentListener::getAnimationInfo(LLSD const &event_data)
                                                "priority", motion->getPriority());
     }
 }
+
+void LLAgentListener::getID(LLSD const& event_data)
+{
+    Response response(llsd::map("id", gAgentID), event_data);
+}
+
+struct AvResultSet : public LL::ResultSet
+{
+    AvResultSet() : LL::ResultSet("nearby_avatars") {}
+    std::vector<LLVOAvatar*> mAvatars;
+
+    int getLength() const override { return narrow(mAvatars.size()); }
+    LLSD getSingle(int index) const override
+    {
+        auto av = mAvatars[index];
+        LLAvatarName av_name;
+        LLAvatarNameCache::get(av->getID(), &av_name);
+        LLVector3 region_pos = av->getCharacterPosition();
+        return llsd::map("id", av->getID(),
+                         "global_pos", ll_sd_from_vector3d(av->getPosGlobalFromAgent(region_pos)),
+                         "region_pos", ll_sd_from_vector3(region_pos),
+                         "name", av_name.getUserName(),
+                         "region_id", av->getRegion()->getRegionID());
+    }
+};
+
+struct ObjResultSet : public LL::ResultSet
+{
+    ObjResultSet() : LL::ResultSet("nearby_objects") {}
+    std::vector<LLViewerObject*> mObjects;
+
+    int getLength() const override { return narrow(mObjects.size()); }
+    LLSD getSingle(int index) const override
+    {
+        auto obj = mObjects[index];
+        return llsd::map("id", obj->getID(),
+                         "global_pos", ll_sd_from_vector3d(obj->getPositionGlobal()),
+                         "region_pos", ll_sd_from_vector3(obj->getPositionRegion()),
+                         "region_id", obj->getRegion()->getRegionID());
+    }
+};
+
+
+F32 get_search_radius(LLSD const& event_data)
+{
+    static LLCachedControl<F32> render_far_clip(gSavedSettings, "RenderFarClip", 64);
+    F32 dist = render_far_clip;
+    if (event_data.has("dist"))
+    {
+        dist = llclamp((F32)event_data["dist"].asReal(), 1, 512);
+    }
+   return dist * dist;
+}
+
+void LLAgentListener::getNearbyAvatarsList(LLSD const& event_data)
+{
+    Response response(LLSD(), event_data);
+    auto avresult = new AvResultSet;
+
+    F32 radius = get_search_radius(event_data);
+    LLVector3d agent_pos = gAgent.getPositionGlobal();
+    for (LLCharacter* character : LLCharacter::sInstances)
+    {
+        LLVOAvatar* avatar = (LLVOAvatar*)character;
+        if (!avatar->isDead() && !avatar->isControlAvatar() && !avatar->isSelf())
+        {
+            if ((dist_vec_squared(avatar->getPositionGlobal(), agent_pos) <= radius))
+            {
+                avresult->mAvatars.push_back(avatar);
+            }
+        }
+    }
+    response["result"] = avresult->getKeyLength();
+}
+
+void LLAgentListener::getNearbyObjectsList(LLSD const& event_data)
+{
+    Response response(LLSD(), event_data);
+    auto objresult = new ObjResultSet;
+
+    F32 radius = get_search_radius(event_data);
+    S32 num_objects = gObjectList.getNumObjects();
+    LLVector3d agent_pos = gAgent.getPositionGlobal();
+    for (S32 i = 0; i < num_objects; ++i)
+    {
+        LLViewerObject* object = gObjectList.getObject(i);
+        if (object && object->getVolume() && !object->isAttachment())
+        {
+            if ((dist_vec_squared(object->getPositionGlobal(), agent_pos) <= radius))
+            {
+                objresult->mObjects.push_back(object);
+            }
+        }
+    }
+    response["result"] = objresult->getKeyLength();
+}
+
+void LLAgentListener::getAgentScreenPos(LLSD const& event_data)
+{
+    Response response(LLSD(), event_data);
+    LLVector3 render_pos;
+    if (event_data.has("avatar_id") && (event_data["avatar_id"] != gAgentID))
+    {
+        LLUUID avatar_id(event_data["avatar_id"]);
+        for (LLCharacter* character : LLCharacter::sInstances)
+        {
+            LLVOAvatar* avatar = (LLVOAvatar*)character;
+            if (!avatar->isDead() && (avatar->getID() == avatar_id))
+            {
+                render_pos = avatar->getRenderPosition();
+                break;
+            }
+        }
+    }
+    else if (gAgentAvatarp.notNull() && gAgentAvatarp->isValid())
+    {
+        render_pos = gAgentAvatarp->getRenderPosition();
+    }
+    LLCoordGL screen_pos;
+    response["onscreen"] = LLViewerCamera::getInstance()->projectPosAgentToScreen(render_pos, screen_pos, false);
+    response["x"] = screen_pos.mX;
+    response["y"] = screen_pos.mY;
+}
diff --git a/indra/newview/llagentlistener.h b/indra/newview/llagentlistener.h
index 05724ff443..8801c9f7ea 100644
--- a/indra/newview/llagentlistener.h
+++ b/indra/newview/llagentlistener.h
@@ -67,6 +67,11 @@ private:
     void stopAnimation(LLSD const &event_data);
     void getAnimationInfo(LLSD const &event_data);
 
+    void getID(LLSD const& event_data);
+    void getNearbyAvatarsList(LLSD const& event_data);
+    void getNearbyObjectsList(LLSD const& event_data);
+    void getAgentScreenPos(LLSD const& event_data);
+
     LLViewerObject * findObjectClosestTo( const LLVector3 & position, bool sit_target = false ) const;
 
 private:
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index acc79ed994..46681af808 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -255,6 +255,10 @@ using namespace LL;
 #include "llcoproceduremanager.h"
 #include "llviewereventrecorder.h"
 
+#include "rlvactions.h"
+#include "rlvcommon.h"
+#include "rlvhandler.h"
+
 // *FIX: These extern globals should be cleaned up.
 // The globals either represent state/config/resource-storage of either
 // this app, or another 'component' of the viewer. App globals should be
@@ -1818,6 +1822,9 @@ bool LLAppViewer::cleanup()
     //ditch LLVOAvatarSelf instance
     gAgentAvatarp = NULL;
 
+    // Sanity check to catch cases where someone forgot to do an RlvActions::isRlvEnabled() check
+    LL_ERRS_IF(!RlvHandler::isEnabled() && RlvHandler::instanceExists()) << "RLV handler instance exists even though RLVa is disabled" << LL_ENDL;
+
     LLNotifications::instance().clear();
 
     // workaround for DEV-35406 crash on shutdown
@@ -3456,6 +3463,7 @@ LLSD LLAppViewer::getViewerInfo() const
     }
 #endif
 
+    info["RLV_VERSION"] = RlvActions::isRlvEnabled() ? Rlv::Strings::getVersionAbout() : "(disabled)";
     info["OPENGL_VERSION"] = ll_safe_string((const char*)(glGetString(GL_VERSION)));
 
     // Settings
diff --git a/indra/newview/llavataractions.cpp b/indra/newview/llavataractions.cpp
index 6f6b89ea81..aff959d279 100644
--- a/indra/newview/llavataractions.cpp
+++ b/indra/newview/llavataractions.cpp
@@ -285,25 +285,18 @@ void LLAvatarActions::startAdhocCall(const uuid_vec_t& ids, const LLUUID& floate
     make_ui_sound("UISndStartIM");
 }
 
-/* AD *TODO: Is this function needed any more?
-    I fixed it a bit(added check for canCall), but it appears that it is not used
-    anywhere. Maybe it should be removed?
 // static
-bool LLAvatarActions::isCalling(const LLUUID &id)
+bool LLAvatarActions::canCall()
 {
-    if (id.isNull() || !canCall())
-    {
-        return false;
-    }
-
-    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
-    return (LLIMModel::getInstance()->findIMSession(session_id) != NULL);
-}*/
+    LLVoiceClient* voice_client = LLVoiceClient::getInstance();
+    return voice_client->voiceEnabled() && voice_client->isVoiceWorking();
+}
 
-//static
-bool LLAvatarActions::canCall()
+// static
+bool LLAvatarActions::canCallTo(const LLUUID& id)
 {
-    return LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
+    LLVoiceClient* voice_client = LLVoiceClient::getInstance();
+    return voice_client->voiceEnabled() && voice_client->isVoiceWorking() && voice_client->getVoiceEnabled(id);
 }
 
 // static
diff --git a/indra/newview/llavataractions.h b/indra/newview/llavataractions.h
index 1f5a42ed22..6f469e96ce 100644
--- a/indra/newview/llavataractions.h
+++ b/indra/newview/llavataractions.h
@@ -172,18 +172,15 @@ public:
     static bool canBlock(const LLUUID& id);
 
     /**
-     * Return true if the avatar is in a P2P voice call with a given user
+     * @return true if voice calls are available
      */
-    /* AD *TODO: Is this function needed any more?
-        I fixed it a bit(added check for canCall), but it appears that it is not used
-        anywhere. Maybe it should be removed?
-    static bool isCalling(const LLUUID &id);*/
+    static bool canCall();
 
     /**
      * @return true if call to the resident can be made
      */
+    static bool canCallTo(const LLUUID& id);
 
-    static bool canCall();
     /**
      * Invite avatar to a group.
      */
diff --git a/indra/newview/llchathistory.cpp b/indra/newview/llchathistory.cpp
index 3e02820feb..bb5ee558ca 100644
--- a/indra/newview/llchathistory.cpp
+++ b/indra/newview/llchathistory.cpp
@@ -426,6 +426,7 @@ public:
                 time_t current_time = time_corrected();
                 time_t message_time = (time_t)(current_time - LLFrameTimer::getElapsedSeconds() + mTime);
 
+                // Report abuse shouldn't use AM/PM, use 24-hour time
                 time_string = "[" + LLTrans::getString("TimeMonth") + "]/["
                     + LLTrans::getString("TimeDay") + "]/["
                     + LLTrans::getString("TimeYear") + "] ["
diff --git a/indra/newview/llconversationlog.cpp b/indra/newview/llconversationlog.cpp
index ed563cbec9..ed16a4b135 100644
--- a/indra/newview/llconversationlog.cpp
+++ b/indra/newview/llconversationlog.cpp
@@ -118,11 +118,21 @@ const std::string LLConversation::createTimestamp(const U64Seconds& utc_time)
     LLSD substitution;
     substitution["datetime"] = (S32)utc_time.value();
 
-    timeStr = "["+LLTrans::getString ("TimeMonth")+"]/["
-                 +LLTrans::getString ("TimeDay")+"]/["
-                 +LLTrans::getString ("TimeYear")+"] ["
-                 +LLTrans::getString ("TimeHour")+"]:["
-                 +LLTrans::getString ("TimeMin")+"]";
+    static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+    timeStr = "[" + LLTrans::getString("TimeMonth") + "]/["
+        + LLTrans::getString("TimeDay") + "]/["
+        + LLTrans::getString("TimeYear") + "] [";
+    if (use_24h)
+    {
+        timeStr += LLTrans::getString("TimeHour") + "]:["
+            + LLTrans::getString("TimeMin") + "]";
+    }
+    else
+    {
+        timeStr += LLTrans::getString("TimeHour12") + "]:["
+            + LLTrans::getString("TimeMin") + "] ["
+            + LLTrans::getString("TimeAMPM") + "]";
+    }
 
 
     LLStringUtil::format (timeStr, substitution);
diff --git a/indra/newview/lldirpicker.cpp b/indra/newview/lldirpicker.cpp
index 51157fa430..17edca7ccb 100644
--- a/indra/newview/lldirpicker.cpp
+++ b/indra/newview/lldirpicker.cpp
@@ -41,11 +41,6 @@
 # include "llfilepicker.h"
 #endif
 
-#ifdef LL_FLTK
-  #include "FL/Fl.H"
-  #include "FL/Fl_Native_File_Chooser.H"
-#endif
-
 #if LL_WINDOWS
 #include <shlobj.h>
 #endif
@@ -219,28 +214,20 @@ LLDirPicker::LLDirPicker() :
     mFileName(NULL),
     mLocked(false)
 {
-#ifndef LL_FLTK
     mFilePicker = new LLFilePicker();
-#endif
     reset();
 }
 
 LLDirPicker::~LLDirPicker()
 {
-#ifndef LL_FLTK
     delete mFilePicker;
-#endif
 }
 
 
 void LLDirPicker::reset()
 {
-#ifndef LL_FLTK
     if (mFilePicker)
         mFilePicker->reset();
-#else
-    mDir = "";
-#endif
 }
 
 bool LLDirPicker::getDir(std::string* filename, bool blocking)
@@ -253,39 +240,16 @@ bool LLDirPicker::getDir(std::string* filename, bool blocking)
         return false;
     }
 
-#ifdef LL_FLTK
-    gViewerWindow->getWindow()->beforeDialog();
-    Fl_Native_File_Chooser flDlg;
-    flDlg.title(LLTrans::getString("choose_the_directory").c_str());
-    flDlg.type(Fl_Native_File_Chooser::BROWSE_DIRECTORY );
-    int res = flDlg.show();
-    gViewerWindow->getWindow()->afterDialog();
-    if( res == 0 )
-    {
-        char const *pDir = flDlg.filename(0);
-        if( pDir )
-            mDir = pDir;
-    }
-    else if( res == -1 )
-    {
-        LL_WARNS() << "FLTK failed: " <<  flDlg.errmsg() << LL_ENDL;
-    }
-    return !mDir.empty();
-#endif
     return false;
 }
 
 std::string LLDirPicker::getDirName()
 {
-#ifndef LL_FLTK
     if (mFilePicker)
     {
         return mFilePicker->getFirstFile();
     }
     return "";
-#else
-    return mDir;
-#endif
 }
 
 #else // not implemented
diff --git a/indra/newview/lldirpicker.h b/indra/newview/lldirpicker.h
index 2ac3db7c2e..dc740caab2 100644
--- a/indra/newview/lldirpicker.h
+++ b/indra/newview/lldirpicker.h
@@ -77,10 +77,8 @@ private:
 
 #if LL_LINUX || LL_DARWIN
     // On Linux we just implement LLDirPicker on top of LLFilePicker
-#ifndef LL_FLTK
     LLFilePicker *mFilePicker;
 #endif
-#endif
 
 
     std::string* mFileName;
diff --git a/indra/newview/lldrawpoolterrain.cpp b/indra/newview/lldrawpoolterrain.cpp
index 5e676bc5b3..57def49539 100644
--- a/indra/newview/lldrawpoolterrain.cpp
+++ b/indra/newview/lldrawpoolterrain.cpp
@@ -296,7 +296,7 @@ void LLDrawPoolTerrain::renderFullShaderTextures()
     // GL_BLEND disabled by default
     drawLoop();
 
-    // Disable multitexture
+    // Disable textures
     sShader->disableTexture(LLViewerShaderMgr::TERRAIN_ALPHARAMP);
     sShader->disableTexture(LLViewerShaderMgr::TERRAIN_DETAIL0);
     sShader->disableTexture(LLViewerShaderMgr::TERRAIN_DETAIL1);
@@ -557,7 +557,7 @@ void LLDrawPoolTerrain::renderFullShaderPBR(bool use_local_materials)
     // GL_BLEND disabled by default
     drawLoop();
 
-    // Disable multitexture
+    // Disable textures
 
     if (paint_type == TERRAIN_PAINT_TYPE_HEIGHTMAP_WITH_NOISE)
     {
@@ -769,7 +769,7 @@ void LLDrawPoolTerrain::renderFull4TU()
     }
 
     LLVertexBuffer::unbind();
-    // Disable multitexture
+    // Disable textures
     gGL.getTexUnit(3)->unbind(LLTexUnit::TT_TEXTURE);
     gGL.getTexUnit(3)->disable();
     gGL.getTexUnit(3)->activate();
@@ -949,7 +949,7 @@ void LLDrawPoolTerrain::renderFull2TU()
     // Restore blend state
     gGL.setSceneBlendType(LLRender::BT_ALPHA);
 
-    // Disable multitexture
+    // Disable textures
 
     gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
     gGL.getTexUnit(1)->disable();
diff --git a/indra/newview/llfilepicker.h b/indra/newview/llfilepicker.h
index e0bd32fe70..4d71a3b392 100644
--- a/indra/newview/llfilepicker.h
+++ b/indra/newview/llfilepicker.h
@@ -174,14 +174,6 @@ private:
                                  void *userdata);
 #endif
 
-#if LL_FLTK
-    enum EType
-    {
-     eSaveFile, eOpenFile, eOpenMultiple
-    };
-    bool openFileDialog( int32_t filter, bool blocking, EType aType );
-#endif
-
     std::vector<std::string> mFiles;
     S32 mCurrentFile;
     bool mLocked;
diff --git a/indra/newview/llfloaterbump.cpp b/indra/newview/llfloaterbump.cpp
index d56e6cdf20..2a4f1ddd12 100644
--- a/indra/newview/llfloaterbump.cpp
+++ b/indra/newview/llfloaterbump.cpp
@@ -56,7 +56,7 @@ LLFloaterBump::LLFloaterBump(const LLSD& key)
     mCommitCallbackRegistrar.add("ShowAgentProfile", { boost::bind(&LLFloaterBump::showProfile, this), cb_info::UNTRUSTED_THROTTLE });
     mCommitCallbackRegistrar.add("Avatar.InviteToGroup", { boost::bind(&LLFloaterBump::inviteToGroup, this), cb_info::UNTRUSTED_THROTTLE });
     mCommitCallbackRegistrar.add("Avatar.Call", { boost::bind(&LLFloaterBump::startCall, this), cb_info::UNTRUSTED_BLOCK });
-    mEnableCallbackRegistrar.add("Avatar.EnableCall", boost::bind(&LLAvatarActions::canCall));
+    mEnableCallbackRegistrar.add("Avatar.EnableCall", { boost::bind(&LLFloaterBump::canCall, this), cb_info::UNTRUSTED_BLOCK });
     mCommitCallbackRegistrar.add("Avatar.AddFriend", { boost::bind(&LLFloaterBump::addFriend, this), cb_info::UNTRUSTED_THROTTLE });
     mEnableCallbackRegistrar.add("Avatar.EnableAddFriend", boost::bind(&LLFloaterBump::enableAddFriend, this));
     mCommitCallbackRegistrar.add("Avatar.Mute", { boost::bind(&LLFloaterBump::muteAvatar, this), cb_info::UNTRUSTED_BLOCK });
@@ -214,6 +214,11 @@ void LLFloaterBump::startCall()
     LLAvatarActions::startCall(mItemUUID);
 }
 
+bool LLFloaterBump::canCall()
+{
+    return LLAvatarActions::canCallTo(mItemUUID);
+}
+
 void LLFloaterBump::reportAbuse()
 {
     LLFloaterReporter::showFromAvatar(mItemUUID, "av_name");
diff --git a/indra/newview/llfloaterbump.h b/indra/newview/llfloaterbump.h
index 53e730d73f..48d6f7e33e 100644
--- a/indra/newview/llfloaterbump.h
+++ b/indra/newview/llfloaterbump.h
@@ -52,6 +52,7 @@ public:
 
     void startIM();
     void startCall();
+    bool canCall();
     void reportAbuse();
     void showProfile();
     void addFriend();
diff --git a/indra/newview/llfloaterimcontainer.cpp b/indra/newview/llfloaterimcontainer.cpp
index 1e2d790cfc..ed24a8af57 100644
--- a/indra/newview/llfloaterimcontainer.cpp
+++ b/indra/newview/llfloaterimcontainer.cpp
@@ -1592,15 +1592,15 @@ bool LLFloaterIMContainer::enableContextMenuItem(const std::string& item, uuid_v
     }
     else if ("can_call" == item)
     {
+        if (is_single_select)
+        {
+            return LLAvatarActions::canCallTo(single_id);
+        }
         return LLAvatarActions::canCall();
     }
     else if ("can_open_voice_conversation" == item)
     {
-        return is_single_select && LLAvatarActions::canCall();
-    }
-    else if ("can_open_voice_conversation" == item)
-    {
-        return is_single_select && LLAvatarActions::canCall();
+        return is_single_select && LLAvatarActions::canCallTo(single_id);
     }
     else if ("can_zoom_in" == item)
     {
diff --git a/indra/newview/llfloaterimsessiontab.cpp b/indra/newview/llfloaterimsessiontab.cpp
index b2f2984c65..0855a628fb 100644
--- a/indra/newview/llfloaterimsessiontab.cpp
+++ b/indra/newview/llfloaterimsessiontab.cpp
@@ -39,6 +39,7 @@
 #include "llchicletbar.h"
 #include "lldraghandle.h"
 #include "llemojidictionary.h"
+#include "llemojihelper.h"
 #include "llfloaterreg.h"
 #include "llfloateremojipicker.h"
 #include "llfloaterimsession.h"
@@ -298,6 +299,8 @@ bool LLFloaterIMSessionTab::postBuild()
 
     mEmojiPickerShowBtn = getChild<LLButton>("emoji_picker_show_btn");
     mEmojiPickerShowBtn->setClickedCallback([this](LLUICtrl*, const LLSD&) { onEmojiPickerShowBtnClicked(); });
+    mEmojiPickerShowBtn->setMouseDownCallback([this](LLUICtrl*, const LLSD&) { onEmojiPickerShowBtnDown(); });
+    mEmojiCloseConn = LLEmojiHelper::instance().setCloseCallback([this](LLUICtrl*, const LLSD&) { onEmojiPickerClosed(); });
 
     mGearBtn = getChild<LLButton>("gear_btn");
     mAddBtn = getChild<LLButton>("add_btn");
@@ -526,8 +529,43 @@ void LLFloaterIMSessionTab::onEmojiRecentPanelToggleBtnClicked()
 
 void LLFloaterIMSessionTab::onEmojiPickerShowBtnClicked()
 {
-    mInputEditor->setFocus(true);
-    mInputEditor->showEmojiHelper();
+    if (!mEmojiPickerShowBtn->getToggleState())
+    {
+        mInputEditor->hideEmojiHelper();
+        mInputEditor->setFocus(true);
+        mInputEditor->showEmojiHelper();
+        mEmojiPickerShowBtn->setToggleState(true); // in case hideEmojiHelper closed a visible instance
+    }
+    else
+    {
+        mInputEditor->hideEmojiHelper();
+        mEmojiPickerShowBtn->setToggleState(false);
+    }
+}
+
+void LLFloaterIMSessionTab::onEmojiPickerShowBtnDown()
+{
+    if (mEmojiHelperLastCallbackFrame == LLFrameTimer::getFrameCount())
+    {
+        // Helper gets closed by focus lost event on Down before before onEmojiPickerShowBtnDown
+        // triggers.
+        // If this condition is true, user pressed button and it was 'toggled' during press,
+        // restore 'toggled' state so that button will not reopen helper.
+        mEmojiPickerShowBtn->setToggleState(true);
+    }
+}
+
+void LLFloaterIMSessionTab::onEmojiPickerClosed()
+{
+    if (mEmojiPickerShowBtn->getToggleState())
+    {
+        mEmojiPickerShowBtn->setToggleState(false);
+        // Helper gets closed by focus lost event on Down before onEmojiPickerShowBtnDown
+        // triggers. If mEmojiHelperLastCallbackFrame is set and matches Down, means close
+        // was triggered by user's press.
+        // A bit hacky, but I can't think of a better way to handle this without rewriting helper.
+        mEmojiHelperLastCallbackFrame = LLFrameTimer::getFrameCount();
+    }
 }
 
 void LLFloaterIMSessionTab::initEmojiRecentPanel()
@@ -591,8 +629,19 @@ void LLFloaterIMSessionTab::deleteAllChildren()
 
 std::string LLFloaterIMSessionTab::appendTime()
 {
-    std::string timeStr = "[" + LLTrans::getString("TimeHour") + "]:"
-                          "[" + LLTrans::getString("TimeMin") + "]";
+    std::string timeStr;
+    static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+    if (use_24h)
+    {
+        timeStr = "[" + LLTrans::getString("TimeHour") + "]:"
+            "[" + LLTrans::getString("TimeMin") + "]";
+    }
+    else
+    {
+        timeStr = "[" + LLTrans::getString("TimeHour12") + "]:"
+            "[" + LLTrans::getString("TimeMin") + "] ["
+            + LLTrans::getString("TimeAMPM") + "]";
+    }
 
     LLSD substitution;
     substitution["datetime"] = (S32)time_corrected();
diff --git a/indra/newview/llfloaterimsessiontab.h b/indra/newview/llfloaterimsessiontab.h
index bee5c8c2c4..890c920bbe 100644
--- a/indra/newview/llfloaterimsessiontab.h
+++ b/indra/newview/llfloaterimsessiontab.h
@@ -227,6 +227,8 @@ private:
 
     void onEmojiRecentPanelToggleBtnClicked();
     void onEmojiPickerShowBtnClicked();
+    void onEmojiPickerShowBtnDown();
+    void onEmojiPickerClosed();
     void initEmojiRecentPanel();
     void onEmojiRecentPanelFocusReceived();
     void onEmojiRecentPanelFocusLost();
@@ -241,6 +243,9 @@ private:
     S32 mInputEditorPad;
     S32 mChatLayoutPanelHeight;
     S32 mFloaterHeight;
+
+    boost::signals2::connection mEmojiCloseConn;
+    U32 mEmojiHelperLastCallbackFrame = { 0 };
 };
 
 
diff --git a/indra/newview/llfloaterinspect.cpp b/indra/newview/llfloaterinspect.cpp
index 0f1eb0cef0..5dea46843c 100644
--- a/indra/newview/llfloaterinspect.cpp
+++ b/indra/newview/llfloaterinspect.cpp
@@ -220,7 +220,8 @@ void LLFloaterInspect::refresh()
         }
 
         time_t timestamp = (time_t) (obj->mCreationDate/1000000);
-        std::string timeStr = getString("timeStamp");
+        static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+        std::string timeStr = use_24h ? getString("timeStamp") : getString("timeStampAMPM");
         LLSD substitution;
         substitution["datetime"] = (S32) timestamp;
         LLStringUtil::format (timeStr, substitution);
diff --git a/indra/newview/llfloaterland.cpp b/indra/newview/llfloaterland.cpp
index 52a3e78d04..5c5219bcdd 100644
--- a/indra/newview/llfloaterland.cpp
+++ b/indra/newview/llfloaterland.cpp
@@ -733,7 +733,8 @@ void LLPanelLandGeneral::refresh()
 
             // Display claim date
             time_t claim_date = parcel->getClaimDate();
-            std::string claim_date_str = getString("time_stamp_template");
+            static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+            std::string claim_date_str = use_24h ? getString("time_stamp_template") : getString("time_stamp_template_ampm");
             LLSD substitution;
             substitution["datetime"] = (S32) claim_date;
             LLStringUtil::format (claim_date_str, substitution);
diff --git a/indra/newview/llfloaterluadebug.cpp b/indra/newview/llfloaterluadebug.cpp
index 06877df816..7a7824c7e6 100644
--- a/indra/newview/llfloaterluadebug.cpp
+++ b/indra/newview/llfloaterluadebug.cpp
@@ -58,7 +58,9 @@ bool LLFloaterLUADebug::postBuild()
         .listen("LLFloaterLUADebug",
                 [mResultOutput=mResultOutput](const LLSD& data)
                 {
-                    mResultOutput->pasteTextWithLinebreaks(data.asString());
+                    LLCachedControl<bool> show_source_info(gSavedSettings, "LuaDebugShowSource", false);
+                    std::string source_info = show_source_info ? data["source_info"].asString() : "";
+                    mResultOutput->pasteTextWithLinebreaks(stringize(data["level"].asString(), source_info, data["msg"].asString()));
                     mResultOutput->addLineBreakChar(true);
                     return false;
                 });
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 0c96c93d31..d7ac8f0552 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -473,6 +473,8 @@ bool LLFloaterPreference::postBuild()
     getChild<LLUICtrl>("log_path_string")->setEnabled(false); // make it read-only but selectable
 
     getChild<LLComboBox>("language_combobox")->setCommitCallback(boost::bind(&LLFloaterPreference::onLanguageChange, this));
+    mTimeFormatCombobox = getChild<LLComboBox>("time_format_combobox");
+    mTimeFormatCombobox->setCommitCallback(boost::bind(&LLFloaterPreference::onTimeFormatChange, this));
 
     getChild<LLComboBox>("FriendIMOptions")->setCommitCallback(boost::bind(&LLFloaterPreference::onNotificationsChange, this,"FriendIMOptions"));
     getChild<LLComboBox>("NonFriendIMOptions")->setCommitCallback(boost::bind(&LLFloaterPreference::onNotificationsChange, this,"NonFriendIMOptions"));
@@ -1108,6 +1110,13 @@ void LLFloaterPreference::onLanguageChange()
     }
 }
 
+void LLFloaterPreference::onTimeFormatChange()
+{
+    std::string val = mTimeFormatCombobox->getValue();
+    gSavedSettings.setBOOL("Use24HourClock", val == "1");
+    onLanguageChange();
+}
+
 void LLFloaterPreference::onNotificationsChange(const std::string& OptionName)
 {
     mNotificationOptions[OptionName] = getChild<LLComboBox>(OptionName)->getSelectedItemLabel();
@@ -1331,6 +1340,8 @@ void LLFloaterPreference::refresh()
         advanced->refresh();
     }
     updateClickActionViews();
+
+    mTimeFormatCombobox->selectByValue(gSavedSettings.getBOOL("Use24HourClock") ? "1" : "0");
 }
 
 void LLFloaterPreference::onCommitWindowedMode()
diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h
index e06e758e3a..d5bd43e0ab 100644
--- a/indra/newview/llfloaterpreference.h
+++ b/indra/newview/llfloaterpreference.h
@@ -124,6 +124,7 @@ protected:
     void        onClickClearCache();            // Clear viewer texture cache, file cache on next startup
     void        onClickBrowserClearCache();     // Clear web history and caches as well as viewer caches above
     void        onLanguageChange();
+    void        onTimeFormatChange();
     void        onNotificationsChange(const std::string& OptionName);
     void        onNameTagOpacityChange(const LLSD& newvalue);
 
@@ -242,6 +243,7 @@ private:
     LLButton*       mDeleteTranscriptsBtn = nullptr;
     LLButton*       mEnablePopupBtn = nullptr;
     LLButton*       mDisablePopupBtn = nullptr;
+    LLComboBox*     mTimeFormatCombobox = nullptr;
     std::unique_ptr< ll::prefs::SearchData > mSearchData;
     bool mSearchDataDirty;
 
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index 165fb5ef88..ac3e942e15 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -148,40 +148,6 @@ public:
     static LLSD getIDs( sparam_t::const_iterator it, sparam_t::const_iterator end, S32 count );
 };
 
-
-/*
-void unpack_request_params(
-    LLMessageSystem* msg,
-    LLDispatcher::sparam_t& strings,
-    LLDispatcher::iparam_t& integers)
-{
-    char str_buf[MAX_STRING];
-    S32 str_count = msg->getNumberOfBlocksFast(_PREHASH_StringData);
-    S32 i;
-    for (i = 0; i < str_count; ++i)
-    {
-        // we treat the SParam as binary data (since it might be an
-        // LLUUID in compressed form which may have embedded \0's,)
-        str_buf[0] = '\0';
-        S32 data_size = msg->getSizeFast(_PREHASH_StringData, i, _PREHASH_SParam);
-        if (data_size >= 0)
-        {
-            msg->getBinaryDataFast(_PREHASH_StringData, _PREHASH_SParam,
-                                   str_buf, data_size, i, MAX_STRING - 1);
-            strings.push_back(std::string(str_buf, data_size));
-        }
-    }
-
-    U32 int_buf;
-    S32 int_count = msg->getNumberOfBlocksFast(_PREHASH_IntegerData);
-    for (i = 0; i < int_count; ++i)
-    {
-        msg->getU32("IntegerData", "IParam", int_buf, i);
-        integers.push_back(int_buf);
-    }
-}
-*/
-
 class LLPanelRegionEnvironment : public LLPanelEnvironmentInfo
 {
 public:
@@ -326,8 +292,8 @@ void LLFloaterRegionInfo::onOpen(const LLSD& key)
         disableTabCtrls();
         return;
     }
-    refreshFromRegion(gAgent.getRegion());
-    requestRegionInfo();
+    refreshFromRegion(gAgent.getRegion(), ERefreshFromRegionPhase::BeforeRequestRegionInfo);
+    requestRegionInfo(true);
 
     if (!mGodLevelChangeSlot.connected())
     {
@@ -347,12 +313,14 @@ void LLFloaterRegionInfo::onRegionChanged()
 {
     if (getVisible()) //otherwise onOpen will do request
     {
-        requestRegionInfo();
+        requestRegionInfo(false);
     }
 }
 
-void LLFloaterRegionInfo::requestRegionInfo()
+void LLFloaterRegionInfo::requestRegionInfo(bool is_opening)
 {
+    mIsRegionInfoRequestedFromOpening = is_opening;
+
     LLTabContainer* tab = findChild<LLTabContainer>("region_panels");
     if (tab)
     {
@@ -523,8 +491,7 @@ void LLFloaterRegionInfo::processRegionInfo(LLMessageSystem* msg)
 
     panel->getChild<LLSpinCtrl>("agent_limit_spin")->setMaxValue((F32)hard_agent_limit);
 
-    LLPanelRegionGeneralInfo* panel_general = LLFloaterRegionInfo::getPanelGeneral();
-    if (panel)
+    if (LLPanelRegionGeneralInfo* panel_general = LLFloaterRegionInfo::getPanelGeneral())
     {
         panel_general->setObjBonusFactor(object_bonus_factor);
     }
@@ -537,6 +504,18 @@ void LLFloaterRegionInfo::processRegionInfo(LLMessageSystem* msg)
     panel->getChildView("access_combo")->setEnabled(gAgent.isGodlike() || (region && region->canManageEstate() && !teen_grid));
     panel->setCtrlsEnabled(allow_modify);
 
+    panel->getChild<LLLineEditor>("estate_id")->setValue((S32)region_info.mEstateID);
+
+    if (region)
+    {
+        panel->getChild<LLLineEditor>("grid_position_x")->setValue((S32)(region->getOriginGlobal()[VX] / 256));
+        panel->getChild<LLLineEditor>("grid_position_y")->setValue((S32)(region->getOriginGlobal()[VY] / 256));
+    }
+    else
+    {
+        panel->getChild<LLLineEditor>("grid_position_x")->setDefaultText();
+        panel->getChild<LLLineEditor>("grid_position_y")->setDefaultText();
+    }
 
     // DEBUG PANEL
     panel = tab->getChild<LLPanel>("Debug");
@@ -561,21 +540,25 @@ void LLFloaterRegionInfo::processRegionInfo(LLMessageSystem* msg)
     {
         // Note: region info also causes LLRegionInfoModel::instance().update(msg); -> requestRegion(); -> changed message
         // we need to know env version here and in update(msg) to know when to request and when not to, when to filter 'changed'
-        floater->refreshFromRegion(gAgent.getRegion());
+        ERefreshFromRegionPhase phase = floater->mIsRegionInfoRequestedFromOpening ?
+            ERefreshFromRegionPhase::AfterRequestRegionInfo :
+            ERefreshFromRegionPhase::NotFromFloaterOpening;
+        floater->refreshFromRegion(gAgent.getRegion(), phase);
     } // else will rerequest on onOpen either way
 }
 
 // static
-void LLFloaterRegionInfo::sRefreshFromRegion(LLViewerRegion* region)
+void LLFloaterRegionInfo::refreshFromRegion(LLViewerRegion* region)
 {
-    if (region != gAgent.getRegion()) { return; }
-
-    LLFloaterRegionInfo* floater = LLFloaterReg::getTypedInstance<LLFloaterRegionInfo>("region_info");
-    if (!floater) { return; }
+    if (region != gAgent.getRegion())
+        return;
 
-    if (floater->getVisible() && region == gAgent.getRegion())
+    if (LLFloaterRegionInfo* floater = LLFloaterReg::getTypedInstance<LLFloaterRegionInfo>("region_info"))
     {
-        floater->refreshFromRegion(region);
+        if (floater->getVisible() && region == gAgent.getRegion())
+        {
+            floater->refreshFromRegion(region, ERefreshFromRegionPhase::NotFromFloaterOpening);
+        }
     }
 }
 
@@ -682,7 +665,7 @@ void LLFloaterRegionInfo::onTabSelected(const LLSD& param)
     active_panel->onOpen(LLSD());
 }
 
-void LLFloaterRegionInfo::refreshFromRegion(LLViewerRegion* region)
+void LLFloaterRegionInfo::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     if (!region)
     {
@@ -692,7 +675,7 @@ void LLFloaterRegionInfo::refreshFromRegion(LLViewerRegion* region)
     // call refresh from region on all panels
     for (const auto& infoPanel : mInfoPanels)
     {
-        infoPanel->refreshFromRegion(region);
+        infoPanel->refreshFromRegion(region, phase);
     }
     mEnvironmentPanel->refreshFromRegion(region);
 }
@@ -725,7 +708,7 @@ void LLFloaterRegionInfo::onGodLevelChange(U8 god_level)
     LLFloaterRegionInfo* floater = LLFloaterReg::getTypedInstance<LLFloaterRegionInfo>("region_info");
     if (floater && floater->getVisible())
     {
-        refreshFromRegion(gAgent.getRegion());
+        refreshFromRegion(gAgent.getRegion(), ERefreshFromRegionPhase::NotFromFloaterOpening);
     }
 }
 
@@ -795,7 +778,7 @@ void LLPanelRegionInfo::updateChild(LLUICtrl* child_ctr)
 }
 
 // virtual
-bool LLPanelRegionInfo::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelRegionInfo::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     if (region) mHost = region->getHost();
     return true;
@@ -823,12 +806,10 @@ void LLPanelRegionInfo::sendEstateOwnerMessage(
     }
     else
     {
-        strings_t::const_iterator it = strings.begin();
-        strings_t::const_iterator end = strings.end();
-        for(; it != end; ++it)
+        for (const std::string& string : strings)
         {
             msg->nextBlock("ParamList");
-            msg->addString("Parameter", *it);
+            msg->addString("Parameter", string);
         }
     }
     msg->sendReliable(mHost);
@@ -887,13 +868,16 @@ void LLPanelRegionInfo::onClickManageRestartSchedule()
 /////////////////////////////////////////////////////////////////////////////
 // LLPanelRegionGeneralInfo
 //
-bool LLPanelRegionGeneralInfo::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelRegionGeneralInfo::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     bool allow_modify = gAgent.isGodlike() || (region && region->canManageEstate());
     setCtrlsEnabled(allow_modify);
     getChildView("apply_btn")->setEnabled(false);
     getChildView("access_text")->setEnabled(allow_modify);
     // getChildView("access_combo")->setEnabled(allow_modify);
+    getChildView("estate_id")->setEnabled(false);
+    getChildView("grid_position_x")->setEnabled(false);
+    getChildView("grid_position_y")->setEnabled(false);
     // now set in processRegionInfo for teen grid detection
     getChildView("kick_btn")->setEnabled(allow_modify);
     getChildView("kick_all_btn")->setEnabled(allow_modify);
@@ -904,7 +888,7 @@ bool LLPanelRegionGeneralInfo::refreshFromRegion(LLViewerRegion* region)
 
     // Data gets filled in by processRegionInfo
 
-    return LLPanelRegionInfo::refreshFromRegion(region);
+    return LLPanelRegionInfo::refreshFromRegion(region, phase);
 }
 
 bool LLPanelRegionGeneralInfo::postBuild()
@@ -1173,7 +1157,7 @@ bool LLPanelRegionDebugInfo::postBuild()
 }
 
 // virtual
-bool LLPanelRegionDebugInfo::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelRegionDebugInfo::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     bool allow_modify = gAgent.isGodlike() || (region && region->canManageEstate());
     setCtrlsEnabled(allow_modify);
@@ -1191,7 +1175,7 @@ bool LLPanelRegionDebugInfo::refreshFromRegion(LLViewerRegion* region)
     getChildView("cancel_restart_btn")->setEnabled(allow_modify);
     getChildView("region_debug_console_btn")->setEnabled(allow_modify);
 
-    return LLPanelRegionInfo::refreshFromRegion(region);
+    return LLPanelRegionInfo::refreshFromRegion(region, phase);
 }
 
 // virtual
@@ -1233,7 +1217,7 @@ void LLPanelRegionDebugInfo::callbackAvatarID(const uuid_vec_t& ids, const std::
     if (ids.empty() || names.empty()) return;
     mTargetAvatar = ids[0];
     getChild<LLUICtrl>("target_avatar_name")->setValue(LLSD(names[0].getCompleteName()));
-    refreshFromRegion( gAgent.getRegion() );
+    refreshFromRegion(gAgent.getRegion(), ERefreshFromRegionPhase::NotFromFloaterOpening);
 }
 
 // static
@@ -1675,7 +1659,7 @@ void LLPanelRegionTerrainInfo::updateForMaterialType()
 }
 
 // virtual
-bool LLPanelRegionTerrainInfo::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelRegionTerrainInfo::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     bool owner_or_god = gAgent.isGodlike()
                         || (region && (region->getOwner() == gAgent.getID()));
@@ -1819,7 +1803,7 @@ bool LLPanelRegionTerrainInfo::refreshFromRegion(LLViewerRegion* region)
     getChildView("upload_raw_btn")->setEnabled(owner_or_god);
     getChildView("bake_terrain_btn")->setEnabled(owner_or_god);
 
-    return LLPanelRegionInfo::refreshFromRegion(region);
+    return LLPanelRegionInfo::refreshFromRegion(region, phase);
 }
 
 
@@ -2289,25 +2273,27 @@ void LLPanelEstateInfo::updateControls(LLViewerRegion* region)
     refresh();
 }
 
-bool LLPanelEstateInfo::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelEstateInfo::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     updateControls(region);
 
     // let the parent class handle the general data collection.
-    bool rv = LLPanelRegionInfo::refreshFromRegion(region);
-
-    // We want estate info. To make sure it works across region
-    // boundaries and multiple packets, we add a serial number to the
-    // integers and track against that on update.
-    strings_t strings;
-    //integers_t integers;
-    //LLFloaterRegionInfo::incrementSerial();
-    LLFloaterRegionInfo::nextInvoice();
-    LLUUID invoice(LLFloaterRegionInfo::getLastInvoice());
-    //integers.push_back(LLFloaterRegionInfo::());::getPanelEstate();
+    bool rv = LLPanelRegionInfo::refreshFromRegion(region, phase);
 
+    if (phase != ERefreshFromRegionPhase::BeforeRequestRegionInfo)
+    {
+        // We want estate info. To make sure it works across region
+        // boundaries and multiple packets, we add a serial number to the
+        // integers and track against that on update.
+        strings_t strings;
+        //integers_t integers;
+        //LLFloaterRegionInfo::incrementSerial();
+        LLFloaterRegionInfo::nextInvoice();
+        LLUUID invoice(LLFloaterRegionInfo::getLastInvoice());
+        //integers.push_back(LLFloaterRegionInfo::());::getPanelEstate();
 
-    sendEstateOwnerMessage(gMessageSystem, "getinfo", invoice, strings);
+        sendEstateOwnerMessage(gMessageSystem, "getinfo", invoice, strings);
+    }
 
     refresh();
 
@@ -2528,7 +2514,7 @@ LLPanelEstateCovenant::LLPanelEstateCovenant()
 }
 
 // virtual
-bool LLPanelEstateCovenant::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelEstateCovenant::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     LLTextBox* region_name = getChild<LLTextBox>("region_name_text");
     if (region_name)
@@ -2574,13 +2560,17 @@ bool LLPanelEstateCovenant::refreshFromRegion(LLViewerRegion* region)
     getChild<LLButton>("reset_covenant")->setEnabled(gAgent.isGodlike() || (region && region->canManageEstate()));
 
     // let the parent class handle the general data collection.
-    bool rv = LLPanelRegionInfo::refreshFromRegion(region);
-    LLMessageSystem *msg = gMessageSystem;
-    msg->newMessage("EstateCovenantRequest");
-    msg->nextBlockFast(_PREHASH_AgentData);
-    msg->addUUIDFast(_PREHASH_AgentID,  gAgent.getID());
-    msg->addUUIDFast(_PREHASH_SessionID,gAgent.getSessionID());
-    msg->sendReliable(region->getHost());
+    bool rv = LLPanelRegionInfo::refreshFromRegion(region, phase);
+
+    if (phase != ERefreshFromRegionPhase::AfterRequestRegionInfo)
+    {
+        gMessageSystem->newMessage("EstateCovenantRequest");
+        gMessageSystem->nextBlockFast(_PREHASH_AgentData);
+        gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+        gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+        gMessageSystem->sendReliable(region->getHost());
+    }
+
     return rv;
 }
 
@@ -3128,7 +3118,7 @@ std::string LLPanelRegionExperiences::regionCapabilityQuery(LLViewerRegion* regi
     return region->getCapability(cap);
 }
 
-bool LLPanelRegionExperiences::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelRegionExperiences::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     bool allow_modify = gAgent.isGodlike() || (region && region->canManageEstate());
 
@@ -3151,10 +3141,13 @@ bool LLPanelRegionExperiences::refreshFromRegion(LLViewerRegion* region)
     mTrusted->loading();
     mTrusted->setReadonly(!allow_modify);
 
-    LLExperienceCache::instance().getRegionExperiences(boost::bind(&LLPanelRegionExperiences::regionCapabilityQuery, region, _1),
-        boost::bind(&LLPanelRegionExperiences::infoCallback, getDerivedHandle<LLPanelRegionExperiences>(), _1));
+    if (phase != ERefreshFromRegionPhase::AfterRequestRegionInfo)
+    {
+        LLExperienceCache::instance().getRegionExperiences(boost::bind(&LLPanelRegionExperiences::regionCapabilityQuery, region, _1),
+            boost::bind(&LLPanelRegionExperiences::infoCallback, getDerivedHandle<LLPanelRegionExperiences>(), _1));
+    }
 
-    return LLPanelRegionInfo::refreshFromRegion(region);
+    return LLPanelRegionInfo::refreshFromRegion(region, phase);
 }
 
 LLSD LLPanelRegionExperiences::addIds(LLPanelExperienceListEditor* panel)
@@ -4181,35 +4174,32 @@ void LLPanelEstateAccess::copyListToClipboard(std::string list_name)
 {
     LLPanelEstateAccess* panel = LLFloaterRegionInfo::getPanelAccess();
     if (!panel) return;
-    LLNameListCtrl* name_list = panel->getChild<LLNameListCtrl>(list_name);
-    if (!name_list) return;
 
+    LLNameListCtrl* name_list = panel->getChild<LLNameListCtrl>(list_name);
     std::vector<LLScrollListItem*> list_vector = name_list->getAllData();
-    if (list_vector.size() == 0) return;
+    if (list_vector.empty())
+        return;
 
     LLSD::String list_to_copy;
-    for (std::vector<LLScrollListItem*>::const_iterator iter = list_vector.begin();
-         iter != list_vector.end();
-         iter++)
+    for (LLScrollListItem* item : list_vector)
     {
-        LLScrollListItem *item = (*iter);
         if (item)
         {
+            if (!list_to_copy.empty())
+            {
+                list_to_copy += "\n";
+            }
             list_to_copy += item->getColumn(0)->getValue().asString();
         }
-        if (std::next(iter) != list_vector.end())
-        {
-            list_to_copy += "\n";
-        }
     }
 
     LLClipboard::instance().copyToClipboard(utf8str_to_wstring(list_to_copy), 0, static_cast<S32>(list_to_copy.length()));
 }
 
-bool LLPanelEstateAccess::refreshFromRegion(LLViewerRegion* region)
+bool LLPanelEstateAccess::refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase)
 {
     updateLists();
-    return LLPanelRegionInfo::refreshFromRegion(region);
+    return LLPanelRegionInfo::refreshFromRegion(region, phase);
 }
 
 //=========================================================================
diff --git a/indra/newview/llfloaterregioninfo.h b/indra/newview/llfloaterregioninfo.h
index 65c1291728..119f7c98f3 100644
--- a/indra/newview/llfloaterregioninfo.h
+++ b/indra/newview/llfloaterregioninfo.h
@@ -71,6 +71,13 @@ class LLPanelRegionEnvironment;
 
 class LLEventTimer;
 
+enum class ERefreshFromRegionPhase
+{
+    NotFromFloaterOpening,
+    BeforeRequestRegionInfo,
+    AfterRequestRegionInfo
+};
+
 class LLFloaterRegionInfo : public LLFloater
 {
     friend class LLFloaterReg;
@@ -85,7 +92,7 @@ public:
 
     // get and process region info if necessary.
     static void processRegionInfo(LLMessageSystem* msg);
-    static void sRefreshFromRegion(LLViewerRegion* region);
+    static void refreshFromRegion(LLViewerRegion* region);
 
     static const LLUUID& getLastInvoice() { return sRequestInvoice; }
     static void nextInvoice() { sRequestInvoice.generate(); }
@@ -104,7 +111,7 @@ public:
     void refresh() override;
 
     void onRegionChanged();
-    void requestRegionInfo();
+    void requestRegionInfo(bool is_opening);
     void enableTopButtons();
     void disableTopButtons();
 
@@ -116,7 +123,7 @@ private:
 protected:
     void onTabSelected(const LLSD& param);
     void disableTabCtrls();
-    void refreshFromRegion(LLViewerRegion* region);
+    void refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase);
     void onGodLevelChange(U8 god_level);
 
     // member data
@@ -124,6 +131,7 @@ protected:
     typedef std::vector<LLPanelRegionInfo*> info_panels_t;
     info_panels_t mInfoPanels;
     LLPanelRegionEnvironment *mEnvironmentPanel;
+    bool mIsRegionInfoRequestedFromOpening { false };
     //static S32 sRequestSerial;    // serial # of last EstateOwnerRequest
     static LLUUID sRequestInvoice;
 
@@ -144,7 +152,7 @@ public:
     void onChangeAnything();
     static void onChangeText(LLLineEditor* caller, void* user_data);
 
-    virtual bool refreshFromRegion(LLViewerRegion* region);
+    virtual bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase);
     virtual bool estateUpdate(LLMessageSystem* msg) { return true; }
 
     bool postBuild() override;
@@ -190,7 +198,7 @@ public:
         :   LLPanelRegionInfo() {}
     ~LLPanelRegionGeneralInfo() {}
 
-    bool refreshFromRegion(LLViewerRegion* region) override;
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override;
 
     bool postBuild() override;
 
@@ -222,7 +230,7 @@ public:
 
     bool postBuild() override;
 
-    bool refreshFromRegion(LLViewerRegion* region) override;
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override;
 
 protected:
     bool sendUpdate() override;
@@ -254,8 +262,8 @@ public:
 
     bool postBuild() override;
 
-    bool refreshFromRegion(LLViewerRegion* region) override;                // refresh local settings from region update from simulator
-    void setEnvControls(bool available);                                    // Whether environment settings are available for this region
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override; // refresh local settings from region update from simulator
+    void setEnvControls(bool available);                                      // Whether environment settings are available for this region
 
     bool validateTextureSizes();
     bool validateMaterials();
@@ -327,7 +335,7 @@ public:
     static void updateEstateName(const std::string& name);
     static void updateEstateOwnerName(const std::string& name);
 
-    bool refreshFromRegion(LLViewerRegion* region) override;
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override;
     bool estateUpdate(LLMessageSystem* msg) override;
 
     bool postBuild() override;
@@ -364,7 +372,7 @@ public:
 
     bool postBuild() override;
     void updateChild(LLUICtrl* child_ctrl) override;
-    bool refreshFromRegion(LLViewerRegion* region) override;
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override;
     bool estateUpdate(LLMessageSystem* msg) override;
 
     // LLView overrides
@@ -430,7 +438,7 @@ public:
     static void sendEstateExperienceDelta(U32 flags, const LLUUID& agent_id);
 
     static void infoCallback(LLHandle<LLPanelRegionExperiences> handle, const LLSD& content);
-    bool refreshFromRegion(LLViewerRegion* region) override;
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override;
     void sendPurchaseRequest()const;
     void processResponse( const LLSD& content );
 
@@ -470,7 +478,7 @@ public:
     void setPendingUpdate(bool pending) { mPendingUpdate = pending; }
     bool getPendingUpdate() { return mPendingUpdate; }
 
-    bool refreshFromRegion(LLViewerRegion* region) override;
+    bool refreshFromRegion(LLViewerRegion* region, ERefreshFromRegionPhase phase) override;
 
 private:
     void onClickAddAllowedAgent();
diff --git a/indra/newview/llfloaterworldmap.cpp b/indra/newview/llfloaterworldmap.cpp
index dda7266220..4674cd68b6 100755
--- a/indra/newview/llfloaterworldmap.cpp
+++ b/indra/newview/llfloaterworldmap.cpp
@@ -486,8 +486,11 @@ void LLFloaterWorldMap::onOpen(const LLSD& key)
         const LLUUID landmark_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
         LLInventoryModelBackgroundFetch::instance().start(landmark_folder_id);
 
-        mLocationEditor->setFocus( true);
-        gFocusMgr.triggerFocusFlash();
+        if (hasFocus())
+        {
+            mLocationEditor->setFocus( true);
+            gFocusMgr.triggerFocusFlash();
+        }
 
         buildAvatarIDList();
         buildLandmarkIDLists();
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index 57e5030602..2deb7caad5 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -691,11 +691,6 @@ bool LLInvFVBridge::isClipboardPasteableAsLink() const
             {
                 return false;
             }
-            if (item->getAssetUUID().isNull())
-            {
-                // otehrwise AIS will return 'Cannot link to items with a NULL asset_id.'
-                return false;
-            }
         }
         const LLViewerInventoryCategory *cat = model->getCategory(item_id);
         if (cat && LLFolderType::lookupIsProtectedType(cat->getPreferredType()))
@@ -4194,6 +4189,32 @@ void LLFolderBridge::pasteLinkFromClipboard()
         std::vector<LLUUID> objects;
         LLClipboard::instance().pasteFromClipboard(objects);
 
+        if (objects.size() == 0)
+        {
+            LLClipboard::instance().setCutMode(false);
+            return;
+        }
+
+        LLUUID& first_id = objects[0];
+        LLInventoryItem* item = model->getItem(first_id);
+        if (item && item->getAssetUUID().isNull())
+        {
+            if (item->getActualType() == LLAssetType::AT_NOTECARD)
+            {
+                // otehrwise AIS will return 'Cannot link to items with a NULL asset_id.'
+                LLNotificationsUtil::add("CantLinkNotecard");
+                LLClipboard::instance().setCutMode(false);
+                return;
+            }
+            else if (item->getActualType() == LLAssetType::AT_MATERIAL)
+            {
+                LLNotificationsUtil::add("CantLinkMaterial");
+                LLClipboard::instance().setCutMode(false);
+                return;
+            }
+        }
+
+
         LLPointer<LLInventoryCallback> cb = NULL;
         LLInventoryPanel* panel = mInventoryPanel.get();
         if (panel->getRootFolder()->isSingleFolderMode())
diff --git a/indra/newview/llinventorygallery.cpp b/indra/newview/llinventorygallery.cpp
index c4f93cee98..03bafa48bd 100644
--- a/indra/newview/llinventorygallery.cpp
+++ b/indra/newview/llinventorygallery.cpp
@@ -2105,6 +2105,30 @@ void LLInventoryGallery::pasteAsLink()
     std::vector<LLUUID> objects;
     LLClipboard::instance().pasteFromClipboard(objects);
 
+    if (objects.size() == 0)
+    {
+        LLClipboard::instance().setCutMode(false);
+        return;
+    }
+
+    LLUUID& first_id = objects[0];
+    LLInventoryItem* item = gInventory.getItem(first_id);
+    if (item && item->getAssetUUID().isNull())
+    {
+        if (item->getActualType() == LLAssetType::AT_NOTECARD)
+        {
+            LLNotificationsUtil::add("CantLinkNotecard");
+            LLClipboard::instance().setCutMode(false);
+            return;
+        }
+        else if (item->getActualType() == LLAssetType::AT_MATERIAL)
+        {
+            LLNotificationsUtil::add("CantLinkMaterial");
+            LLClipboard::instance().setCutMode(false);
+            return;
+        }
+    }
+
     bool paste_into_root = mSelectedItemIDs.empty();
     for (LLUUID& dest : mSelectedItemIDs)
     {
diff --git a/indra/newview/llinventorygallerymenu.cpp b/indra/newview/llinventorygallerymenu.cpp
index 320cbcdb1e..340ecfcbbc 100644
--- a/indra/newview/llinventorygallerymenu.cpp
+++ b/indra/newview/llinventorygallerymenu.cpp
@@ -772,10 +772,6 @@ void LLInventoryGalleryContextMenu::updateMenuItemsVisibility(LLContextMenu* men
                     {
                         disabled_items.push_back(std::string("Paste As Link"));
                     }
-                    else if (selected_item->getAssetUUID().isNull())
-                    {
-                        disabled_items.push_back(std::string("Paste As Link"));
-                    }
                 }
                 else if (selected_category && LLFolderType::lookupIsProtectedType(selected_category->getPreferredType()))
                 {
diff --git a/indra/newview/llinventorylistener.cpp b/indra/newview/llinventorylistener.cpp
index 79726c3e0b..88b07c0b0b 100644
--- a/indra/newview/llinventorylistener.cpp
+++ b/indra/newview/llinventorylistener.cpp
@@ -116,7 +116,8 @@ struct CatResultSet: public LL::ResultSet
     LLSD getSingle(int index) const override
     {
         auto cat = mCategories[index];
-        return llsd::map("name", cat->getName(),
+        return llsd::map("id", cat->getUUID(),
+                         "name", cat->getName(),
                          "parent_id", cat->getParentUUID(),
                          "type", LLFolderType::lookup(cat->getPreferredType()));
     }
@@ -133,7 +134,8 @@ struct ItemResultSet: public LL::ResultSet
     LLSD getSingle(int index) const override
     {
         auto item = mItems[index];
-        return llsd::map("name", item->getName(),
+        return llsd::map("id", item->getUUID(),
+                         "name", item->getName(),
                          "parent_id", item->getParentUUID(),
                          "desc", item->getDescription(),
                          "inv_type", LLInventoryType::lookup(item->getInventoryType()),
diff --git a/indra/newview/lllogchat.cpp b/indra/newview/lllogchat.cpp
index bf49f33049..51f30dd86b 100644
--- a/indra/newview/lllogchat.cpp
+++ b/indra/newview/lllogchat.cpp
@@ -78,8 +78,8 @@ const static std::string MULTI_LINE_PREFIX(" ");
  *
  * Note: "You" was used as an avatar names in viewers of previous versions
  */
-const static boost::regex TIMESTAMP_AND_STUFF("^(\\[\\d{4}/\\d{1,2}/\\d{1,2}\\s+\\d{1,2}:\\d{2}\\]\\s+|\\[\\d{1,2}:\\d{2}\\]\\s+)?(.*)$");
-const static boost::regex TIMESTAMP("^(\\[\\d{4}/\\d{1,2}/\\d{1,2}\\s+\\d{1,2}:\\d{2}\\]|\\[\\d{1,2}:\\d{2}\\]).*");
+const static boost::regex TIMESTAMP_AND_STUFF("^(\\[\\d{4}/\\d{1,2}/\\d{1,2}\\s+\\d{1,2}:\\d{2}\\s[AaPp][Mm]\\]\\s+|\\[\\d{4}/\\d{1,2}/\\d{1,2}\\s+\\d{1,2}:\\d{2}\\]\\s+|\\[\\d{1,2}:\\d{2}\\s[AaPp][Mm]\\]\\s+|\\[\\d{1,2}:\\d{2}\\]\\s+)?(.*)$");
+const static boost::regex TIMESTAMP("^(\\[\\d{4}/\\d{1,2}/\\d{1,2}\\s+\\d{1,2}:\\d{2}(\\s[AaPp][Mm])?\\]|\\[\\d{1,2}:\\d{2}(\\s[AaPp][Mm])?\\]).*");
 
 /**
  *  Regular expression suitable to match names like
@@ -150,6 +150,10 @@ public:
 
     void checkAndCutOffDate(std::string& time_str)
     {
+        if (time_str.size() < 10) // not enough space for a date
+        {
+            return;
+        }
         // Cuts off the "%Y/%m/%d" from string for todays timestamps.
         // Assume that passed string has at least "%H:%M" time format.
         date log_date(not_a_date_time);
@@ -166,20 +170,12 @@ public:
 
         if ( days_alive == zero_days )
         {
-            // Yep, today's so strip "%Y/%m/%d" info
-            ptime stripped_time(not_a_date_time);
-
-            mTimeStream.str(LLStringUtil::null);
-            mTimeStream << time_str;
-            mTimeStream >> stripped_time;
-            mTimeStream.clear();
-
-            time_str.clear();
-
-            mTimeStream.str(LLStringUtil::null);
-            mTimeStream << stripped_time;
-            mTimeStream >> time_str;
-            mTimeStream.clear();
+            size_t pos = time_str.find_first_of(' ');
+            if (pos != std::string::npos)
+            {
+                time_str.erase(0, pos + 1);
+                LLStringUtil::trim(time_str);
+            }
         }
 
         LL_DEBUGS("LLChatLogParser")
@@ -308,16 +304,22 @@ std::string LLLogChat::timestamp2LogString(U32 timestamp, bool withdate)
     std::string timeStr;
     if (withdate)
     {
-        timeStr = "[" + LLTrans::getString ("TimeYear") + "]/["
-                  + LLTrans::getString ("TimeMonth") + "]/["
-                  + LLTrans::getString ("TimeDay") + "] ["
-                  + LLTrans::getString ("TimeHour") + "]:["
-                  + LLTrans::getString ("TimeMin") + "]";
+        timeStr = "[" + LLTrans::getString("TimeYear") + "]/["
+            + LLTrans::getString("TimeMonth") + "]/["
+            + LLTrans::getString("TimeDay") + "] ";
+    }
+
+    static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+    if (use_24h)
+    {
+        timeStr += "[" + LLTrans::getString("TimeHour") + "]:["
+            + LLTrans::getString("TimeMin") + "]";
     }
     else
     {
-        timeStr = "[" + LLTrans::getString("TimeHour") + "]:["
-                  + LLTrans::getString ("TimeMin")+"]";
+        timeStr += "[" + LLTrans::getString("TimeHour12") + "]:["
+            + LLTrans::getString("TimeMin") + "] ["
+            + LLTrans::getString("TimeAMPM") + "]";
     }
 
     LLSD substitution;
diff --git a/indra/newview/llluamanager.cpp b/indra/newview/llluamanager.cpp
index 322717fbb9..9b6dcc5277 100644
--- a/indra/newview/llluamanager.cpp
+++ b/indra/newview/llluamanager.cpp
@@ -72,9 +72,10 @@ std::string lua_print_msg(lua_State* L, std::string_view level)
     lluau_checkstack(L, 2);
     luaL_where(L, 1);
     // start with the 'where' info at the top of the stack
-    std::ostringstream out;
-    out << lua_tostring(L, -1);
+    std::string source_info{ lua_tostring(L, -1) };
     lua_pop(L, 1);
+
+    std::ostringstream out;
     const char* sep = "";           // 'where' info ends with ": "
     // now iterate over arbitrary args, calling Lua tostring() on each and
     // concatenating with separators
@@ -101,10 +102,10 @@ std::string lua_print_msg(lua_State* L, std::string_view level)
     // capture message string
     std::string msg{ out.str() };
     // put message out there for any interested party (*koff* LLFloaterLUADebug *koff*)
-    LLEventPumps::instance().obtain("lua output").post(stringize(level, ": ", msg));
+    LLEventPumps::instance().obtain("lua output").post(llsd::map("msg", msg, "level", stringize(level, ": "), "source_info", source_info));
 
     llcoro::suspend();
-    return msg;
+    return source_info + msg;
 }
 
 lua_function(print_debug, "print_debug(args...): DEBUG level logging")
diff --git a/indra/newview/llmodelpreview.cpp b/indra/newview/llmodelpreview.cpp
index 1e8b7d39cc..1e7da126b0 100644
--- a/indra/newview/llmodelpreview.cpp
+++ b/indra/newview/llmodelpreview.cpp
@@ -3365,7 +3365,7 @@ bool LLModelPreview::render()
         mFMP->childSetEnabled("upload_joints", upload_skin);
     }
 
-    F32 explode = (F32)mFMP->childGetValue("physics_explode").asReal();
+    F32 physics_explode = (F32)mFMP->childGetValue("physics_explode").asReal();
 
     LLGLDepthTest gls_depth(GL_TRUE); // SL-12781 re-enable z-buffer for 3D model preview
 
@@ -3590,12 +3590,12 @@ bool LLModelPreview::render()
 
                                     for (U32 i = 0; i < physics.mMesh.size(); ++i)
                                     {
-                                        if (explode > 0.f)
+                                        if (physics_explode > 0.f)
                                         {
                                             gGL.pushMatrix();
 
                                             LLVector3 offset = model->mHullCenter[i] - model->mCenterOfHullCenters;
-                                            offset *= explode;
+                                            offset *= physics_explode;
 
                                             gGL.translatef(offset.mV[0], offset.mV[1], offset.mV[2]);
                                         }
@@ -3610,7 +3610,7 @@ bool LLModelPreview::render()
                                         gGL.diffuseColor4ubv(hull_colors[i].mV);
                                         LLVertexBuffer::drawArrays(LLRender::TRIANGLES, physics.mMesh[i].mPositions);
 
-                                        if (explode > 0.f)
+                                        if (physics_explode > 0.f)
                                         {
                                             gGL.popMatrix();
                                         }
@@ -3625,7 +3625,8 @@ bool LLModelPreview::render()
                         if (render_mesh)
                         {
                             auto num_models = mVertexBuffer[LLModel::LOD_PHYSICS][model].size();
-                            if (pass > 0){
+                            if (pass > 0)
+                            {
                                 for (size_t i = 0; i < num_models; ++i)
                                 {
                                     gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
@@ -3805,7 +3806,8 @@ bool LLModelPreview::render()
                             }
                         }
 
-                        for (U32 i = 0, e = static_cast<U32>(mVertexBuffer[mPreviewLOD][model].size()); i < e; ++i)
+                        std::size_t size = mVertexBuffer[mPreviewLOD][model].size();
+                        for (U32 i = 0; i < size; ++i)
                         {
                             model->mSkinInfo.updateHash();
                             LLRenderPass::uploadMatrixPalette(mPreviewAvatar, &model->mSkinInfo);
diff --git a/indra/newview/llnotificationlistitem.cpp b/indra/newview/llnotificationlistitem.cpp
index 5b8b28ebe6..9a33bcb1b9 100644
--- a/indra/newview/llnotificationlistitem.cpp
+++ b/indra/newview/llnotificationlistitem.cpp
@@ -38,6 +38,7 @@
 #include "lluicolortable.h"
 #include "message.h"
 #include "llnotificationsutil.h"
+#include "llviewercontrol.h"
 #include <boost/regex.hpp>
 
 LLNotificationListItem::LLNotificationListItem(const Params& p) : LLPanel(p),
@@ -133,10 +134,22 @@ std::string LLNotificationListItem::buildNotificationDate(const LLDate& time_sta
         default:
             timeStr = "[" + LLTrans::getString("TimeMonth") + "]/["
                 +LLTrans::getString("TimeDay")+"]/["
-                +LLTrans::getString("TimeYear")+"] ["
-                +LLTrans::getString("TimeHour")+"]:["
-                +LLTrans::getString("TimeMin")+"] ["
-                +LLTrans::getString("TimeTimezone")+"]";
+                +LLTrans::getString("TimeYear")+"] [";
+
+            static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+            if (use_24h)
+            {
+                timeStr += LLTrans::getString("TimeHour") + "]:["
+                    + LLTrans::getString("TimeMin") + "] ["
+                    + LLTrans::getString("TimeTimezone") + "]";
+            }
+            else
+            {
+                timeStr += LLTrans::getString("TimeHour12") + "]:["
+                    + LLTrans::getString("TimeMin") + "] ["
+                    + LLTrans::getString("TimeAMPM") + "] ["
+                    + LLTrans::getString("TimeTimezone") + "]";
+            }
             break;
     }
     LLSD substitution;
diff --git a/indra/newview/llpanelenvironment.cpp b/indra/newview/llpanelenvironment.cpp
index be61c44b7c..d3df88b65e 100644
--- a/indra/newview/llpanelenvironment.cpp
+++ b/indra/newview/llpanelenvironment.cpp
@@ -48,6 +48,7 @@
 
 #include "llappviewer.h"
 #include "llcallbacklist.h"
+#include "llviewercontrol.h"
 #include "llviewerparcelmgr.h"
 
 #include "llinventorymodel.h"
@@ -939,19 +940,29 @@ void LLPanelEnvironmentInfo::udpateApparentTimeOfDay()
     S32Hours    hourofday(secondofday);
     S32Seconds  secondofhour(secondofday - hourofday);
     S32Minutes  minutesofhour(secondofhour);
+    static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
     bool        am_pm(hourofday.value() >= 12);
 
-    if (hourofday.value() < 1)
-        hourofday = S32Hours(12);
-    if (hourofday.value() > 12)
-        hourofday -= S32Hours(12);
+    if (!use_24h)
+    {
+        if (hourofday.value() < 1)
+            hourofday = S32Hours(12);
+        if (hourofday.value() > 12)
+            hourofday -= S32Hours(12);
+    }
 
     std::string lblminute(((minutesofhour.value() < 10) ? "0" : "") + LLSD(minutesofhour.value()).asString());
 
-
     mLabelApparentTime->setTextArg("[HH]", LLSD(hourofday.value()).asString());
     mLabelApparentTime->setTextArg("[MM]", lblminute);
-    mLabelApparentTime->setTextArg("[AP]", std::string(am_pm ? "PM" : "AM"));
+    if (use_24h)
+    {
+        mLabelApparentTime->setTextArg("[AP]", std::string());
+    }
+    else
+    {
+        mLabelApparentTime->setTextArg("[AP]", std::string(am_pm ? "PM" : "AM"));
+    }
     mLabelApparentTime->setTextArg("[PRC]", LLSD((S32)(100 * perc)).asString());
 
 }
diff --git a/indra/newview/llpanelgrouproles.cpp b/indra/newview/llpanelgrouproles.cpp
index 4404efff98..e1f2d7588c 100644
--- a/indra/newview/llpanelgrouproles.cpp
+++ b/indra/newview/llpanelgrouproles.cpp
@@ -1360,7 +1360,8 @@ void LLPanelGroupMembersSubTab::activate()
     {
         if (!gdatap || !gdatap->isMemberDataComplete())
         {
-            const U32 page_size = 50;
+            static LLCachedControl<bool> enable_pagination(gSavedSettings, "UseGroupMemberPagination", false);
+            const U32 page_size = enable_pagination() ? 50 : 0;
             std::string sort_column_name = mMembersList->getSortColumnName();
             bool sort_descending = !mMembersList->getSortAscending();
             LLGroupMgr::getInstance()->sendCapGroupMembersRequest(mGroupID, page_size, 0, sort_column_name, sort_descending);
diff --git a/indra/newview/llpanellandmarkinfo.cpp b/indra/newview/llpanellandmarkinfo.cpp
index 41373cd7f5..7596c0eba8 100644
--- a/indra/newview/llpanellandmarkinfo.cpp
+++ b/indra/newview/llpanellandmarkinfo.cpp
@@ -41,6 +41,7 @@
 #include "lllandmarkactions.h"
 #include "llparcel.h"
 #include "llslurl.h"
+#include "llviewercontrol.h"
 #include "llviewerinventory.h"
 #include "llviewerparcelmgr.h"
 #include "llviewerregion.h"
@@ -326,7 +327,8 @@ void LLPanelLandmarkInfo::displayItemInfo(const LLInventoryItem* pItem)
     }
     else
     {
-        std::string timeStr = getString("acquired_date");
+        static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+        std::string timeStr = use_24h ? getString("acquired_date") : getString("acquired_date_ampm");
         LLSD substitution;
         substitution["datetime"] = (S32) time_utc;
         LLStringUtil::format (timeStr, substitution);
diff --git a/indra/newview/llpanelprofile.cpp b/indra/newview/llpanelprofile.cpp
index 2086706bf8..5c54a3fc27 100644
--- a/indra/newview/llpanelprofile.cpp
+++ b/indra/newview/llpanelprofile.cpp
@@ -754,8 +754,6 @@ void LLPanelProfileSecondLife::onOpen(const LLSD& key)
 
     resetData();
 
-    LLUUID avatar_id = getAvatarId();
-
     bool own_profile = getSelfProfile();
 
     mGroupList->setShowNone(!own_profile);
@@ -793,7 +791,6 @@ void LLPanelProfileSecondLife::onOpen(const LLSD& key)
 
     if (!own_profile)
     {
-        mVoiceStatus = LLAvatarActions::canCall() && (LLAvatarActions::isFriend(avatar_id) ? LLAvatarTracker::instance().isBuddyOnline(avatar_id) : true);
         updateOnlineStatus();
         fillRightsData();
     }
@@ -1214,17 +1211,6 @@ void LLPanelProfileSecondLife::changed(U32 mask)
     }
 }
 
-// virtual, called by LLVoiceClient
-void LLPanelProfileSecondLife::onChange(EStatusType status, const LLSD& channelInfo, bool proximal)
-{
-    if(status == STATUS_JOINING || status == STATUS_LEFT_CHANNEL)
-    {
-        return;
-    }
-
-    mVoiceStatus = LLAvatarActions::canCall() && (LLAvatarActions::isFriend(getAvatarId()) ? LLAvatarTracker::instance().isBuddyOnline(getAvatarId()) : true);
-}
-
 void LLPanelProfileSecondLife::setAvatarId(const LLUUID& avatar_id)
 {
     if (avatar_id.notNull())
@@ -1502,7 +1488,7 @@ bool LLPanelProfileSecondLife::onEnableMenu(const LLSD& userdata)
     }
     else if (item_name == "voice_call")
     {
-        return mVoiceStatus;
+        return LLAvatarActions::canCallTo(agent_id);
     }
     else if (item_name == "chat_history")
     {
diff --git a/indra/newview/llpanelprofile.h b/indra/newview/llpanelprofile.h
index c207a4162a..ba00e12441 100644
--- a/indra/newview/llpanelprofile.h
+++ b/indra/newview/llpanelprofile.h
@@ -33,7 +33,6 @@
 #include "llpanel.h"
 #include "llpanelavatar.h"
 #include "llmediactrl.h"
-#include "llvoiceclient.h"
 
 // class LLPanelProfileClassifieds;
 // class LLTabContainer;
@@ -70,7 +69,6 @@ class LLViewerFetchedTexture;
 class LLPanelProfileSecondLife
     : public LLPanelProfilePropertiesProcessorTab
     , public LLFriendObserver
-    , public LLVoiceClientStatusObserver
 {
 public:
     LLPanelProfileSecondLife();
@@ -89,10 +87,6 @@ public:
      */
     void changed(U32 mask) override;
 
-    // Implements LLVoiceClientStatusObserver::onChange() to enable the call
-    // button when voice is available
-    void onChange(EStatusType status, const LLSD& channelInfo, bool proximal) override;
-
     void setAvatarId(const LLUUID& avatar_id) override;
 
     bool postBuild() override;
@@ -203,7 +197,6 @@ private:
     LLHandle<LLFloater> mFloaterTexturePickerHandle;
 
     bool                mHasUnsavedDescriptionChanges;
-    bool                mVoiceStatus;
     bool                mWaitingForImageUpload;
     bool                mAllowPublish;
     bool                mHideAge;
diff --git a/indra/newview/llpanelteleporthistory.cpp b/indra/newview/llpanelteleporthistory.cpp
index ebfdafdfe2..8097e0ac0b 100644
--- a/indra/newview/llpanelteleporthistory.cpp
+++ b/indra/newview/llpanelteleporthistory.cpp
@@ -42,6 +42,7 @@
 #include "llnotificationsutil.h"
 #include "lltextbox.h"
 #include "lltoggleablemenu.h"
+#include "llviewercontrol.h"
 #include "llviewermenu.h"
 #include "lllandmarkactions.h"
 #include "llclipboard.h"
@@ -215,8 +216,18 @@ std::string LLTeleportHistoryFlatItem::getTimestamp()
     // Only show timestamp for today and yesterday
     if(time_diff < seconds_today + seconds_in_day)
     {
-        timestamp = "[" + LLTrans::getString("TimeHour12")+"]:["
-                        + LLTrans::getString("TimeMin")+"] ["+ LLTrans::getString("TimeAMPM")+"]";
+        static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+        if (use_24h)
+        {
+            timestamp = "[" + LLTrans::getString("TimeHour") + "]:["
+                + LLTrans::getString("TimeMin") + "]";
+        }
+        else
+        {
+            timestamp = "[" + LLTrans::getString("TimeHour12") + "]:["
+                + LLTrans::getString("TimeMin") + "] [" + LLTrans::getString("TimeAMPM") + "]";
+        }
+
         LLSD substitution;
         substitution["datetime"] = (S32) date.secondsSinceEpoch();
         LLStringUtil::format(timestamp, substitution);
diff --git a/indra/newview/llpanelvoicedevicesettings.cpp b/indra/newview/llpanelvoicedevicesettings.cpp
index 60877494e7..e65ba523f0 100644
--- a/indra/newview/llpanelvoicedevicesettings.cpp
+++ b/indra/newview/llpanelvoicedevicesettings.cpp
@@ -42,7 +42,7 @@
 
 static LLPanelInjector<LLPanelVoiceDeviceSettings> t_panel_group_general("panel_voice_device_settings");
 static const std::string DEFAULT_DEVICE("Default");
-
+static const std::string NO_DEVICE("No Device");
 
 LLPanelVoiceDeviceSettings::LLPanelVoiceDeviceSettings()
     : LLPanel()
@@ -51,12 +51,10 @@ LLPanelVoiceDeviceSettings::LLPanelVoiceDeviceSettings()
     mCtrlOutputDevices = NULL;
     mInputDevice = gSavedSettings.getString("VoiceInputAudioDevice");
     mOutputDevice = gSavedSettings.getString("VoiceOutputAudioDevice");
-    mDevicesUpdated = false;  //obsolete
     mUseTuningMode = true;
 
     // grab "live" mic volume level
     mMicVolume = gSavedSettings.getF32("AudioLevelMic");
-
 }
 
 LLPanelVoiceDeviceSettings::~LLPanelVoiceDeviceSettings()
@@ -81,7 +79,7 @@ bool LLPanelVoiceDeviceSettings::postBuild()
         boost::bind(&LLPanelVoiceDeviceSettings::onCommitUnmute, this));
 
     mLocalizedDeviceNames[DEFAULT_DEVICE]               = getString("default_text");
-    mLocalizedDeviceNames["No Device"]                  = getString("name_no_device");
+    mLocalizedDeviceNames[NO_DEVICE]                    = getString("name_no_device");
     mLocalizedDeviceNames["Default System Device"]      = getString("name_default_system_device");
 
     mCtrlOutputDevices->setMouseDownCallback(boost::bind(&LLPanelVoiceDeviceSettings::onOutputDevicesClicked, this));
@@ -115,7 +113,7 @@ void LLPanelVoiceDeviceSettings::draw()
     bool voice_enabled = LLVoiceClient::getInstance()->voiceEnabled();
     if (voice_enabled)
     {
-        getChildView("wait_text")->setVisible( !is_in_tuning_mode && mUseTuningMode);
+        getChildView("wait_text")->setVisible(!is_in_tuning_mode && mUseTuningMode);
         getChildView("disabled_text")->setVisible(false);
         mUnmuteBtn->setVisible(false);
     }
@@ -212,56 +210,29 @@ void LLPanelVoiceDeviceSettings::cancel()
 
 void LLPanelVoiceDeviceSettings::refresh()
 {
-    //grab current volume
+    LLVoiceClient* voice_client = LLVoiceClient::getInstance();
+
+    // grab current volume
     LLSlider* volume_slider = getChild<LLSlider>("mic_volume_slider");
+
     // set mic volume tuning slider based on last mic volume setting
     F32 current_volume = (F32)volume_slider->getValue().asReal();
-    LLVoiceClient::getInstance()->tuningSetMicVolume(current_volume);
+    voice_client->tuningSetMicVolume(current_volume);
 
     // Fill in popup menus
-    bool device_settings_available = LLVoiceClient::getInstance()->deviceSettingsAvailable();
+    bool device_settings_available = voice_client->deviceSettingsAvailable();
+    bool device_settings_updated = voice_client->deviceSettingsUpdated();
 
     if (mCtrlInputDevices)
     {
-        mCtrlInputDevices->setEnabled(device_settings_available);
-    }
-
-    if (mCtrlOutputDevices)
-    {
-        mCtrlOutputDevices->setEnabled(device_settings_available);
-    }
-
-    getChild<LLSlider>("mic_volume_slider")->setEnabled(device_settings_available);
-
-    if(!device_settings_available)
-    {
-        // The combo boxes are disabled, since we can't get the device settings from the daemon just now.
-        // Put the currently set default (ONLY) in the box, and select it.
-        if(mCtrlInputDevices)
-        {
-            mCtrlInputDevices->removeall();
-            mCtrlInputDevices->add(getLocalizedDeviceName(mInputDevice), mInputDevice, ADD_BOTTOM);
-            mCtrlInputDevices->setValue(mInputDevice);
-        }
-        if(mCtrlOutputDevices)
-        {
-            mCtrlOutputDevices->removeall();
-            mCtrlOutputDevices->add(getLocalizedDeviceName(mOutputDevice), mOutputDevice, ADD_BOTTOM);
-            mCtrlOutputDevices->setValue(mOutputDevice);
-        }
-    }
-    else if (LLVoiceClient::getInstance()->deviceSettingsUpdated())
-    {
-        LLVoiceDeviceList::const_iterator device;
-
-        if(mCtrlInputDevices)
+        if (device_settings_available && !voice_client->getCaptureDevices().empty())
         {
-            LLVoiceDeviceList devices = LLVoiceClient::getInstance()->getCaptureDevices();
-            if (devices.size() > 0) // if zero, we've not received our devices yet
+            mCtrlInputDevices->setEnabled(true);
+            if (device_settings_updated)
             {
                 mCtrlInputDevices->removeall();
                 mCtrlInputDevices->add(getLocalizedDeviceName(DEFAULT_DEVICE), DEFAULT_DEVICE, ADD_BOTTOM);
-                for (auto& device : devices)
+                for (auto& device : voice_client->getCaptureDevices())
                 {
                     mCtrlInputDevices->add(getLocalizedDeviceName(device.display_name), device.full_name, ADD_BOTTOM);
                 }
@@ -275,16 +246,24 @@ void LLPanelVoiceDeviceSettings::refresh()
                 }
             }
         }
+        else
+        {
+            mCtrlInputDevices->setEnabled(false);
+            mCtrlInputDevices->removeall();
+            mCtrlInputDevices->setLabel(getLocalizedDeviceName(NO_DEVICE));
+        }
+    }
 
-        if(mCtrlOutputDevices)
+    if (mCtrlOutputDevices)
+    {
+        if (device_settings_available && !voice_client->getRenderDevices().empty())
         {
-            LLVoiceDeviceList devices = LLVoiceClient::getInstance()->getRenderDevices();
-            if (devices.size() > 0)  // if zero, we've not received our devices yet
+            mCtrlOutputDevices->setEnabled(true);
+            if (device_settings_updated)
             {
                 mCtrlOutputDevices->removeall();
                 mCtrlOutputDevices->add(getLocalizedDeviceName(DEFAULT_DEVICE), DEFAULT_DEVICE, ADD_BOTTOM);
-
-                for (auto& device : devices)
+                for (auto& device : voice_client->getRenderDevices())
                 {
                     mCtrlOutputDevices->add(getLocalizedDeviceName(device.display_name), device.full_name, ADD_BOTTOM);
                 }
@@ -298,7 +277,15 @@ void LLPanelVoiceDeviceSettings::refresh()
                 }
             }
         }
+        else
+        {
+            mCtrlOutputDevices->setEnabled(false);
+            mCtrlOutputDevices->removeall();
+            mCtrlOutputDevices->setLabel(getLocalizedDeviceName(NO_DEVICE));
+        }
     }
+
+    getChild<LLSlider>("mic_volume_slider")->setEnabled(device_settings_available && !voice_client->getCaptureDevices().empty());
 }
 
 void LLPanelVoiceDeviceSettings::initialize()
diff --git a/indra/newview/llpanelvoicedevicesettings.h b/indra/newview/llpanelvoicedevicesettings.h
index 815396cbd1..d0d14c212c 100644
--- a/indra/newview/llpanelvoicedevicesettings.h
+++ b/indra/newview/llpanelvoicedevicesettings.h
@@ -63,7 +63,6 @@ protected:
     class LLComboBox        *mCtrlInputDevices;
     class LLComboBox        *mCtrlOutputDevices;
     class LLButton          *mUnmuteBtn;
-    bool mDevicesUpdated;
     bool mUseTuningMode;
     std::map<std::string, std::string> mLocalizedDeviceNames;
 };
diff --git a/indra/newview/llsettingsvo.cpp b/indra/newview/llsettingsvo.cpp
index 34b8535c84..fee0bbcda4 100644
--- a/indra/newview/llsettingsvo.cpp
+++ b/indra/newview/llsettingsvo.cpp
@@ -671,7 +671,8 @@ void LLSettingsVOSky::updateSettings()
     // After some A/B comparison of relesae vs EEP, tweak to allow strength to fall below 2
     // at night, for better match. (mSceneLightStrength is a divisor, so lower value means brighter
     // local lights)
-    F32 sun_dynamic_range = llmax(gSavedSettings.getF32("RenderSunDynamicRange"), 0.0001f);
+    LLCachedControl<F32> sdr(gSavedSettings, "RenderSunDynamicRange", 1.f);
+    F32 sun_dynamic_range = llmax(sdr(), 0.0001f);
     mSceneLightStrength = 2.0f * (0.75f + sun_dynamic_range * dp);
 
     gSky.setSunAndMoonDirectionsCFR(sun_direction, moon_direction);
diff --git a/indra/newview/llsidepaneliteminfo.cpp b/indra/newview/llsidepaneliteminfo.cpp
index fccf745a74..385e4314a9 100644
--- a/indra/newview/llsidepaneliteminfo.cpp
+++ b/indra/newview/llsidepaneliteminfo.cpp
@@ -483,7 +483,8 @@ void LLSidepanelItemInfo::refreshFromItem(LLViewerInventoryItem* item)
     }
     else
     {
-        std::string timeStr = getString("acquiredDate");
+        static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+        std::string timeStr = use_24h ? getString("acquiredDate") : getString("acquiredDateAMPM");
         LLSD substitution;
         substitution["datetime"] = (S32) time_utc;
         LLStringUtil::format (timeStr, substitution);
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 83d6b57fa4..dd8c6d989e 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -204,6 +204,7 @@
 #include "threadpool.h"
 #include "llperfstats.h"
 
+#include "rlvhandler.h"
 
 #if LL_WINDOWS
 #include "lldxhardware.h"
@@ -875,6 +876,8 @@ bool idle_startup()
             return false;
         }
 
+        RlvHandler::setEnabled(gSavedSettings.get<bool>(Rlv::Settings::Main));
+
         // reset the values that could have come in from a slurl
         // DEV-42215: Make sure they're not empty -- gUserCredential
         // might already have been set from gSavedSettings, and it's too bad
diff --git a/indra/newview/llterrainpaintmap.cpp b/indra/newview/llterrainpaintmap.cpp
index 8ccde74c93..a858f92d8e 100644
--- a/indra/newview/llterrainpaintmap.cpp
+++ b/indra/newview/llterrainpaintmap.cpp
@@ -31,6 +31,8 @@
 // library includes
 #include "llglslshader.h"
 #include "llrendertarget.h"
+#include "llrender2dutils.h"
+#include "llshadermgr.h"
 #include "llvertexbuffer.h"
 
 // newview includes
@@ -38,18 +40,31 @@
 #include "llsurface.h"
 #include "llsurfacepatch.h"
 #include "llviewercamera.h"
+#include "llviewercontrol.h"
 #include "llviewerregion.h"
 #include "llviewershadermgr.h"
 #include "llviewertexture.h"
 
-// static
-bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& region, LLViewerTexture& tex)
+namespace
+{
+#ifdef SHOW_ASSERT
+void check_tex(const LLViewerTexture& tex)
 {
     llassert(tex.getComponents() == 3);
     llassert(tex.getWidth() > 0 && tex.getHeight() > 0);
     llassert(tex.getWidth() == tex.getHeight());
     llassert(tex.getPrimaryFormat() == GL_RGB);
     llassert(tex.getGLTexture());
+}
+#else
+#define check_tex(tex)
+#endif
+} // namespace
+
+// static
+bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& region, LLViewerTexture& tex)
+{
+    check_tex(tex);
 
     const LLSurface& surface = region.getLand();
     const U32 patch_count = surface.getPatchesPerEdge();
@@ -76,8 +91,8 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion&
     // Bind the debug shader and render terrain to tex
     // Use a scratch render target because its dimensions may exceed the standard bake target, and this is a one-off bake
     LLRenderTarget scratch_target;
-    const S32 dim = llmin(tex.getWidth(), tex.getHeight());
-    scratch_target.allocate(dim, dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,
+    const S32 max_dim = llmax(tex.getWidth(), tex.getHeight());
+    scratch_target.allocate(max_dim, max_dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,
                                    LLTexUnit::eTextureMipGeneration::TMG_NONE);
     if (!scratch_target.isComplete())
     {
@@ -104,6 +119,7 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion&
     const F32 region_half_width = region_width / 2.0f;
     const F32 region_camera_height = surface.getMaxZ() + DEFAULT_NEAR_PLANE;
     LLViewerCamera camera;
+    // TODO: Huh... I just realized this view vector is not completely vertical
     const LLVector3 region_center = LLVector3(region_half_width, region_half_width, 0.0) + region.getOriginAgent();
     const LLVector3 camera_origin = LLVector3(0.0f, 0.0f, region_camera_height) + region_center;
     camera.lookAt(camera_origin, region_center, LLVector3::y_axis);
@@ -237,6 +253,7 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion&
 
         S32 alpha_ramp = shader.enableTexture(LLViewerShaderMgr::TERRAIN_ALPHARAMP);
         LLPointer<LLViewerTexture> alpha_ramp_texture = LLViewerTextureManager::getFetchedTexture(IMG_ALPHA_GRAD_2D);
+        // TODO: Consider using LLGLSLShader::bindTexture
         gGL.getTexUnit(alpha_ramp)->bind(alpha_ramp_texture);
         gGL.getTexUnit(alpha_ramp)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 
@@ -250,6 +267,7 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion&
                 const U32 vertex_offset = n * patch_index;
                 llassert(index_offset + ni <= region_indices);
                 llassert(vertex_offset + n <= region_vertices);
+                // TODO: Try a single big drawRange and see if that still works
                 buf->drawRange(LLRender::TRIANGLES, vertex_offset, vertex_offset + n - 1, ni, index_offset);
             }
         }
@@ -269,7 +287,7 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion&
     gGL.flush();
     LLVertexBuffer::unbind();
     // Final step: Copy the output to the terrain paintmap
-    const bool success = tex.getGLTexture()->setSubImageFromFrameBuffer(0, 0, 0, 0, dim, dim);
+    const bool success = tex.getGLTexture()->setSubImageFromFrameBuffer(0, 0, 0, 0, tex.getWidth(), tex.getHeight());
     if (!success)
     {
         LL_WARNS() << "Failed to copy framebuffer to paintmap" << LL_ENDL;
@@ -283,3 +301,687 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion&
 
     return success;
 }
+
+// *TODO: Decide when to apply the paint queue - ideally once per frame per region
+// Applies paints and then clears the paint queue
+// *NOTE The paint queue is also cleared when setting the paintmap texture
+void LLTerrainPaintMap::applyPaintQueueRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue)
+{
+    if (queue.empty()) { return; }
+
+    check_tex(tex);
+
+    gGL.getTexUnit(0)->bind(tex.getGLTexture(), false, true);
+
+    // glTexSubImage2D replaces all pixels in the rectangular region. That
+    // makes it unsuitable for alpha.
+    llassert(queue.getComponents() == LLTerrainPaint::RGB);
+    constexpr GLenum pixformat = GL_RGB;
+
+    const std::vector<LLTerrainPaint::ptr_t>& queue_list = queue.get();
+    for (size_t i = 0; i < queue_list.size(); ++i)
+    {
+        // It is currently the responsibility of the paint queue to convert
+        // incoming bits to the right bit depth for the paintmap (this could
+        // change in the future).
+        queue.convertBitDepths(i, 8);
+        const LLTerrainPaint::ptr_t& paint = queue_list[i];
+
+        if (paint->mData.empty()) { continue; }
+        constexpr GLint level = 0;
+        if ((paint->mStartX >= tex.getWidth() - 1) || (paint->mStartY >= tex.getHeight() - 1)) { continue; }
+        constexpr GLint miplevel = 0;
+        const S32 x_offset = paint->mStartX;
+        const S32 y_offset = paint->mStartY;
+        const S32 width = llmin(paint->mWidthX, tex.getWidth() - x_offset);
+        const S32 height = llmin(paint->mWidthY, tex.getHeight() - y_offset);
+        const U8* pixels = paint->mData.data();
+        constexpr GLenum pixtype = GL_UNSIGNED_BYTE;
+        // *TODO: Performance suggestion: Use the sub-image utility function
+        // that LLImageGL::setSubImage uses to split texture updates into
+        // lines, if that's faster.
+        glTexSubImage2D(GL_TEXTURE_2D, miplevel, x_offset, y_offset, width, height, pixformat, pixtype, pixels);
+        stop_glerror();
+    }
+
+    // Generating mipmaps at the end...
+    glGenerateMipmap(GL_TEXTURE_2D);
+    stop_glerror();
+
+    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
+    queue.clear();
+}
+
+namespace
+{
+
+// A general-purpose vertex buffer of a quad for stamping textures on the z=0
+// plane.
+// *NOTE: Because we know the vertex XY coordinates go from 0 to 1
+// pre-transform, UVs can be calculated from the vertices
+LLVertexBuffer* get_paint_triangle_buffer()
+{
+    static LLPointer<LLVertexBuffer> buf = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX);
+    static bool initialized = false;
+    if (!initialized)
+    {
+        // Two triangles forming a square from (0,0) to (1,1)
+        buf->allocateBuffer(/*vertices =*/ 4, /*indices =*/ 6);
+        LLStrider<U16> indices;
+        LLStrider<LLVector3> vertices;
+        buf->getVertexStrider(vertices);
+        buf->getIndexStrider(indices);
+        // y
+        //    2....3
+        // ^  .    .
+        // |  0....1
+        // |
+        // ------->  x
+        //
+        // triangle 1: 0,1,2
+        // triangle 2: 1,3,2
+        (*(vertices++)).set(0.0f, 0.0f, 0.0f);
+        (*(vertices++)).set(1.0f, 0.0f, 0.0f);
+        (*(vertices++)).set(0.0f, 1.0f, 0.0f);
+        (*(vertices++)).set(1.0f, 1.0f, 0.0f);
+        *(indices++) = 0;
+        *(indices++) = 1;
+        *(indices++) = 2;
+        *(indices++) = 1;
+        *(indices++) = 3;
+        *(indices++) = 2;
+        buf->unmapBuffer();
+    }
+    return buf.get();
+}
+
+};
+
+// static
+LLTerrainPaintQueue LLTerrainPaintMap::convertPaintQueueRGBAToRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue_in)
+{
+    check_tex(tex);
+    llassert(queue_in.getComponents() == LLTerrainPaint::RGBA);
+
+    // TODO: Avoid allocating a scratch render buffer and use mAuxillaryRT instead
+    // TODO: even if it means performing extra render operations to apply the paints, in rare cases where the paints can't all fit within an area that can be represented by the buffer
+    LLRenderTarget scratch_target;
+    const S32 max_dim = llmax(tex.getWidth(), tex.getHeight());
+    scratch_target.allocate(max_dim, max_dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,
+                                   LLTexUnit::eTextureMipGeneration::TMG_NONE);
+    if (!scratch_target.isComplete())
+    {
+        llassert(false);
+        LL_WARNS() << "Failed to allocate render target" << LL_ENDL;
+        return false;
+    }
+    gGL.getTexUnit(0)->disable();
+    stop_glerror();
+
+    scratch_target.bindTarget();
+    glClearColor(0, 0, 0, 0);
+    scratch_target.clear();
+    const F32 target_half_width = (F32)scratch_target.getWidth() / 2.0f;
+    const F32 target_half_height = (F32)scratch_target.getHeight() / 2.0f;
+
+    LLVertexBuffer* buf = get_paint_triangle_buffer();
+
+    // Update projection matrix and viewport
+    // *NOTE: gl_state_for_2d also sets the modelview matrix. This will be overridden later.
+    {
+        stop_glerror();
+        gGL.matrixMode(LLRender::MM_PROJECTION);
+        gGL.pushMatrix();
+        gGL.loadIdentity();
+        gGL.ortho(-target_half_width, target_half_width, -target_half_height, target_half_height, 0.25f, 1.0f);
+        stop_glerror();
+        const LLRect texture_rect(0, scratch_target.getHeight(), scratch_target.getWidth(), 0);
+        glViewport(texture_rect.mLeft, texture_rect.mBottom, texture_rect.getWidth(), texture_rect.getHeight());
+    }
+
+    // View matrix
+    // Coordinates should be in pixels. 1.0f = 1 pixel on the framebuffer.
+    // Camera is centered in the middle of the framebuffer.
+    glm::mat4 view(glm::make_mat4((GLfloat*) OGL_TO_CFR_ROTATION));
+    {
+        LLViewerCamera camera;
+        const LLVector3 camera_origin(target_half_width, target_half_height, 0.5f);
+        const LLVector3 camera_look_down(target_half_width, target_half_height, 0.0f);
+        camera.lookAt(camera_origin, camera_look_down, LLVector3::y_axis);
+        camera.setAspect(F32(scratch_target.getHeight()) / F32(scratch_target.getWidth()));
+        GLfloat ogl_matrix[16];
+        camera.getOpenGLTransform(ogl_matrix);
+        view *= glm::make_mat4(ogl_matrix);
+    }
+
+    LLGLDisable stencil(GL_STENCIL_TEST);
+    LLGLDisable scissor(GL_SCISSOR_TEST);
+    LLGLEnable cull_face(GL_CULL_FACE);
+    LLGLDepthTest depth_test(GL_FALSE, GL_FALSE, GL_ALWAYS);
+    LLGLEnable blend(GL_BLEND);
+    gGL.setSceneBlendType(LLRender::BT_ALPHA);
+
+    LLGLSLShader& shader = gTerrainStampProgram;
+    shader.bind();
+
+    // First, apply the paint map as the background
+    {
+        glm::mat4 model;
+        {
+            model = glm::scale(model, glm::vec3((F32)tex.getWidth(), (F32)tex.getHeight(), 1.0f));
+            model = glm::translate(model, glm::vec3(0.0f, 0.0f, 0.0f));
+        }
+        glm::mat4 modelview = view * model;
+        gGL.matrixMode(LLRender::MM_MODELVIEW);
+        gGL.loadMatrix(glm::value_ptr(modelview));
+
+        shader.bindTexture(LLShaderMgr::DIFFUSE_MAP, &tex);
+        // We care about the whole paintmap, which is already a power of two.
+        // Hence, TERRAIN_STAMP_SCALE = (1.0,1.0)
+        shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, 1.0f, 1.0f);
+        buf->setBuffer();
+        buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);
+    }
+
+    LLTerrainPaintQueue queue_out(LLTerrainPaint::RGB);
+
+    // Incrementally apply each RGBA paint to the render target, then extract
+    // the result back into memory as an RGB paint.
+    // Put each result in queue_out.
+    const std::vector<LLTerrainPaint::ptr_t>& queue_in_list = queue_in.get();
+    for (size_t i = 0; i < queue_in_list.size(); ++i)
+    {
+        // It is currently the responsibility of the paint queue to convert
+        // incoming bits to the right bit depth for paint operations (this
+        // could change in the future).
+        queue_in.convertBitDepths(i, 8);
+        const LLTerrainPaint::ptr_t& paint_in = queue_in_list[i];
+
+        // Modelview matrix for the current paint
+        // View matrix is already computed. Just need the model matrix.
+        // Orthographic projection matrix is already updated
+        glm::mat4 model;
+        {
+            model = glm::scale(model, glm::vec3(paint_in->mWidthX, paint_in->mWidthY, 1.0f));
+            model = glm::translate(model, glm::vec3(paint_in->mStartX, paint_in->mStartY, 0.0f));
+        }
+        glm::mat4 modelview = view * model;
+        gGL.matrixMode(LLRender::MM_MODELVIEW);
+        gGL.loadMatrix(glm::value_ptr(modelview));
+
+        // Generate temporary stamp texture from paint contents.
+        // Our stamp image needs to be a power of two.
+        // Because the paint data may not cover a whole power-of-two region,
+        // allocate a bigger 2x2 image if needed, but set the image data later
+        // for a subset of the image.
+        // Pixel data outside this subset is left undefined. We will use
+        // TERRAIN_STAMP_SCALE in the stamp shader to define the subset of the
+        // image we care about.
+        const U32 width_rounded =  1 << U32(ceil(log2(F32(paint_in->mWidthX))));
+        const U32 height_rounded = 1 << U32(ceil(log2(F32(paint_in->mWidthY))));
+        LLPointer<LLImageGL> stamp_image;
+        {
+            // Create image object (dimensions not yet initialized in GL)
+            U32 stamp_tex_name;
+            LLImageGL::generateTextures(1, &stamp_tex_name);
+            const U32 components = paint_in->mComponents;
+            constexpr LLGLenum target = GL_TEXTURE_2D;
+            const LLGLenum internal_format = paint_in->mComponents == 4 ? GL_RGBA8 : GL_RGB8;
+            const LLGLenum format = paint_in->mComponents == 4 ? GL_RGBA : GL_RGB;
+            constexpr LLGLenum type = GL_UNSIGNED_BYTE;
+            stamp_image = new LLImageGL(stamp_tex_name, components, target, internal_format, format, type, LLTexUnit::TAM_WRAP);
+            // Nearest-neighbor filtering to reduce surprises
+            stamp_image->setFilteringOption(LLTexUnit::TFO_POINT);
+
+            // Initialize the image dimensions in GL
+            constexpr U8* undefined_data_for_now = nullptr;
+            gGL.getTexUnit(0)->bind(stamp_image, false, true);
+            glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width_rounded, height_rounded, 0, format, type, undefined_data_for_now);
+            gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+            stamp_image->setSize(width_rounded, height_rounded, components);
+            stamp_image->setDiscardLevel(0);
+
+            // Manually set a subset of the image in GL
+            const U8* data = paint_in->mData.data();
+            const S32 data_width = paint_in->mWidthX;
+            const S32 data_height = paint_in->mWidthY;
+            constexpr S32 origin = 0;
+            // width = data_width; height = data_height. i.e.: Copy the full
+            // contents of data into the image.
+            stamp_image->setSubImage(data, data_width, data_height, origin, origin, /*width=*/data_width, /*height=*/data_height);
+        }
+
+        // Apply ("stamp") the paint to the render target
+        {
+            shader.bindTextureImageGL(LLShaderMgr::DIFFUSE_MAP, stamp_image);
+            const F32 width_fraction = F32(paint_in->mWidthX) / F32(width_rounded);
+            const F32 height_fraction = F32(paint_in->mWidthY) / F32(height_rounded);
+            shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, width_fraction, height_fraction);
+            buf->setBuffer();
+            buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);
+        }
+
+        // Extract the result back into memory as an RGB paint
+        LLTerrainPaint::ptr_t paint_out = std::make_shared<LLTerrainPaint>();
+        {
+            paint_out->mStartX = paint_in->mStartX;
+            paint_out->mStartY = paint_in->mStartY;
+            paint_out->mWidthX = paint_in->mWidthX;
+            paint_out->mWidthY = paint_in->mWidthY;
+            paint_out->mBitDepth = 8; // Will be reduced to TerrainPaintBitDepth bits later
+            paint_out->mComponents = LLTerrainPaint::RGB;
+#ifdef SHOW_ASSERT
+            paint_out->assert_confined_to(tex);
+#endif
+            paint_out->confine_to(tex);
+            paint_out->mData.resize(paint_out->mComponents * paint_out->mWidthX * paint_out->mWidthY);
+            constexpr GLint miplevel = 0;
+            const S32 x_offset = paint_out->mStartX;
+            const S32 y_offset = paint_out->mStartY;
+            const S32 width = paint_out->mWidthX;
+            const S32 height = paint_out->mWidthY;
+            constexpr GLenum pixformat = GL_RGB;
+            constexpr GLenum pixtype = GL_UNSIGNED_BYTE;
+            llassert(paint_out->mData.size() <= std::numeric_limits<GLsizei>::max());
+            const GLsizei buf_size = (GLsizei)paint_out->mData.size();
+            U8* pixels = paint_out->mData.data();
+            glReadPixels(x_offset, y_offset, width, height, pixformat, pixtype, pixels);
+        }
+
+        // Enqueue the result to the new paint queue, with bit depths per color
+        // channel reduced from 8 to 5, and reduced from RGBA (paintmap
+        // sub-rectangle update with alpha mask) to RGB (paintmap sub-rectangle
+        // update without alpha mask). This format is suitable for sending
+        // over the network.
+        // *TODO: At some point, queue_out will pass through a network
+        // round-trip which will reduce the bit depth, making the
+        // pre-conversion step not necessary.
+        queue_out.enqueue(paint_out);
+        LLCachedControl<U32> bit_depth(gSavedSettings, "TerrainPaintBitDepth");
+        queue_out.convertBitDepths(queue_out.size()-1, bit_depth);
+    }
+
+    queue_in.clear();
+
+    scratch_target.flush();
+
+    LLGLSLShader::unbind();
+
+    gGL.matrixMode(LLRender::MM_PROJECTION);
+    gGL.popMatrix();
+
+    return queue_out;
+}
+
+// static
+LLTerrainPaintQueue LLTerrainPaintMap::convertBrushQueueToPaintRGB(const LLViewerRegion& region, LLViewerTexture& tex, LLTerrainBrushQueue& queue_in)
+{
+    check_tex(tex);
+
+    // TODO: Avoid allocating a scratch render buffer and use mAuxillaryRT instead
+    // TODO: even if it means performing extra render operations to apply the brushes, in rare cases where the paints can't all fit within an area that can be represented by the buffer
+    LLRenderTarget scratch_target;
+    const S32 max_dim = llmax(tex.getWidth(), tex.getHeight());
+    scratch_target.allocate(max_dim, max_dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,
+                                   LLTexUnit::eTextureMipGeneration::TMG_NONE);
+    if (!scratch_target.isComplete())
+    {
+        llassert(false);
+        LL_WARNS() << "Failed to allocate render target" << LL_ENDL;
+        return false;
+    }
+    gGL.getTexUnit(0)->disable();
+    stop_glerror();
+
+    scratch_target.bindTarget();
+    glClearColor(0, 0, 0, 0);
+    scratch_target.clear();
+    const F32 target_half_width = (F32)scratch_target.getWidth() / 2.0f;
+    const F32 target_half_height = (F32)scratch_target.getHeight() / 2.0f;
+
+    LLVertexBuffer* buf = get_paint_triangle_buffer();
+
+    // Update projection matrix and viewport
+    // *NOTE: gl_state_for_2d also sets the modelview matrix. This will be overridden later.
+    {
+        stop_glerror();
+        gGL.matrixMode(LLRender::MM_PROJECTION);
+        gGL.pushMatrix();
+        gGL.loadIdentity();
+        gGL.ortho(-target_half_width, target_half_width, -target_half_height, target_half_height, 0.25f, 1.0f);
+        stop_glerror();
+        const LLRect texture_rect(0, scratch_target.getHeight(), scratch_target.getWidth(), 0);
+        glViewport(texture_rect.mLeft, texture_rect.mBottom, texture_rect.getWidth(), texture_rect.getHeight());
+    }
+
+    // View matrix
+    // Coordinates should be in pixels. 1.0f = 1 pixel on the framebuffer.
+    // Camera is centered in the middle of the framebuffer.
+    glm::mat4 view(glm::make_mat4((GLfloat*)OGL_TO_CFR_ROTATION));
+    {
+        LLViewerCamera camera;
+        const LLVector3 camera_origin(target_half_width, target_half_height, 0.5f);
+        const LLVector3 camera_look_down(target_half_width, target_half_height, 0.0f);
+        camera.lookAt(camera_origin, camera_look_down, LLVector3::y_axis);
+        camera.setAspect(F32(scratch_target.getHeight()) / F32(scratch_target.getWidth()));
+        GLfloat ogl_matrix[16];
+        camera.getOpenGLTransform(ogl_matrix);
+        view *= glm::make_mat4(ogl_matrix);
+    }
+
+    LLGLDisable stencil(GL_STENCIL_TEST);
+    LLGLDisable scissor(GL_SCISSOR_TEST);
+    LLGLEnable cull_face(GL_CULL_FACE);
+    LLGLDepthTest depth_test(GL_FALSE, GL_FALSE, GL_ALWAYS);
+    LLGLEnable blend(GL_BLEND);
+    gGL.setSceneBlendType(LLRender::BT_ALPHA);
+
+    LLGLSLShader& shader = gTerrainStampProgram;
+    shader.bind();
+
+    // First, apply the paint map as the background
+    {
+        glm::mat4 model;
+        {
+            model = glm::scale(model, glm::vec3((F32)tex.getWidth(), (F32)tex.getHeight(), 1.0f));
+            model = glm::translate(model, glm::vec3(0.0f, 0.0f, 0.0f));
+        }
+        glm::mat4 modelview = view * model;
+        gGL.matrixMode(LLRender::MM_MODELVIEW);
+        gGL.loadMatrix(glm::value_ptr(modelview));
+
+        shader.bindTexture(LLShaderMgr::DIFFUSE_MAP, &tex);
+        // We care about the whole paintmap, which is already a power of two.
+        // Hence, TERRAIN_STAMP_SCALE = (1.0,1.0)
+        shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, 1.0f, 1.0f);
+        buf->setBuffer();
+        buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);
+    }
+
+    LLTerrainPaintQueue queue_out(LLTerrainPaint::RGB);
+
+    // Incrementally apply each brush stroke to the render target, then extract
+    // the result back into memory as an RGB paint.
+    // Put each result in queue_out.
+    const std::vector<LLTerrainBrush::ptr_t>& brush_list = queue_in.get();
+    for (size_t i = 0; i < brush_list.size(); ++i)
+    {
+        const LLTerrainBrush::ptr_t& brush_in = brush_list[i];
+
+        // Modelview matrix for the current brush
+        // View matrix is already computed. Just need the model matrix.
+        // Orthographic projection matrix is already updated
+        // *NOTE: Brush path information is in region space. It will need to be
+        // converted to paintmap pixel space before it makes sense.
+        F32 brush_width_x;
+        F32 brush_width_y;
+        F32 brush_start_x;
+        F32 brush_start_y;
+        {
+            F32 min_x = brush_in->mPath[0].mV[VX];
+            F32 max_x = min_x;
+            F32 min_y = brush_in->mPath[0].mV[VY];
+            F32 max_y = min_y;
+            for (size_t i = 1; i < brush_in->mPath.size(); ++i)
+            {
+                const F32 x = brush_in->mPath[i].mV[VX];
+                const F32 y = brush_in->mPath[i].mV[VY];
+                min_x = llmin(min_x, x);
+                max_x = llmax(max_x, x);
+                min_y = llmin(min_y, y);
+                max_y = llmax(max_y, y);
+            }
+            brush_width_x = brush_in->mBrushSize + (max_x - min_x);
+            brush_width_y = brush_in->mBrushSize + (max_y - min_y);
+            brush_start_x = min_x - (brush_in->mBrushSize / 2.0f);
+            brush_start_y = min_y - (brush_in->mBrushSize / 2.0f);
+            // Convert brush path information to paintmap pixel space from region
+            // space.
+            brush_width_x *= tex.getWidth()  / region.getWidth();
+            brush_width_y *= tex.getHeight() / region.getWidth();
+            brush_start_x *= tex.getWidth()  / region.getWidth();
+            brush_start_y *= tex.getHeight() / region.getWidth();
+        }
+        glm::mat4 model;
+        {
+            model = glm::scale(model, glm::vec3(brush_width_x, brush_width_y, 1.0f));
+            model = glm::translate(model, glm::vec3(brush_start_x, brush_start_y, 0.0f));
+        }
+        glm::mat4 modelview = view * model;
+        gGL.matrixMode(LLRender::MM_MODELVIEW);
+        gGL.loadMatrix(glm::value_ptr(modelview));
+
+        // Apply the "brush" to the render target
+        {
+            // TODO: Use different shader for this - currently this is using the stamp shader. The white image is just a placeholder for now
+            shader.bindTexture(LLShaderMgr::DIFFUSE_MAP, LLViewerFetchedTexture::sWhiteImagep);
+            shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, 1.0f, 1.0f);
+            buf->setBuffer();
+            buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);
+        }
+
+        // Extract the result back into memory as an RGB paint
+        LLTerrainPaint::ptr_t paint_out = std::make_shared<LLTerrainPaint>();
+        {
+            paint_out->mStartX = U16(floor(brush_start_x));
+            paint_out->mStartY = U16(floor(brush_start_y));
+            const F32 dX = brush_start_x - F32(paint_out->mStartX);
+            const F32 dY = brush_start_y - F32(paint_out->mStartY);
+            paint_out->mWidthX = U16(ceil(brush_width_x + dX));
+            paint_out->mWidthY = U16(ceil(brush_width_y + dY));
+            paint_out->mBitDepth = 8; // Will be reduced to TerrainPaintBitDepth bits later
+            paint_out->mComponents = LLTerrainPaint::RGB;
+            // The brush strokes are expected to sometimes partially venture
+            // outside of the paintmap bounds.
+            paint_out->confine_to(tex);
+            paint_out->mData.resize(paint_out->mComponents * paint_out->mWidthX * paint_out->mWidthY);
+            constexpr GLint miplevel = 0;
+            const S32 x_offset = paint_out->mStartX;
+            const S32 y_offset = paint_out->mStartY;
+            const S32 width = paint_out->mWidthX;
+            const S32 height = paint_out->mWidthY;
+            constexpr GLenum pixformat = GL_RGB;
+            constexpr GLenum pixtype = GL_UNSIGNED_BYTE;
+            llassert(paint_out->mData.size() <= std::numeric_limits<GLsizei>::max());
+            const GLsizei buf_size = (GLsizei)paint_out->mData.size();
+            U8* pixels = paint_out->mData.data();
+            glReadPixels(x_offset, y_offset, width, height, pixformat, pixtype, pixels);
+        }
+
+        // Enqueue the result to the new paint queue, with bit depths per color
+        // channel reduced from 8 to 5, and reduced from RGBA (paintmap
+        // sub-rectangle update with alpha mask) to RGB (paintmap sub-rectangle
+        // update without alpha mask). This format is suitable for sending
+        // over the network.
+        // *TODO: At some point, queue_out will pass through a network
+        // round-trip which will reduce the bit depth, making the
+        // pre-conversion step not necessary.
+        queue_out.enqueue(paint_out);
+        LLCachedControl<U32> bit_depth(gSavedSettings, "TerrainPaintBitDepth");
+        queue_out.convertBitDepths(queue_out.size()-1, bit_depth);
+    }
+
+    queue_in.clear();
+
+    scratch_target.flush();
+
+    LLGLSLShader::unbind();
+
+    gGL.matrixMode(LLRender::MM_PROJECTION);
+    gGL.popMatrix();
+
+    return queue_out;
+}
+
+template<typename T>
+LLTerrainQueue<T>::LLTerrainQueue(LLTerrainQueue<T>& other)
+{
+    *this = other;
+}
+
+template<typename T>
+LLTerrainQueue<T>& LLTerrainQueue<T>::operator=(LLTerrainQueue<T>& other)
+{
+    mList = other.mList;
+    return *this;
+}
+
+template<typename T>
+bool LLTerrainQueue<T>::enqueue(std::shared_ptr<T>& t, bool dry_run)
+{
+    if (!dry_run) { mList.push_back(t); }
+    return true;
+}
+
+template<typename T>
+bool LLTerrainQueue<T>::enqueue(std::vector<std::shared_ptr<T>>& list)
+{
+    constexpr bool dry_run = true;
+    for (auto& t : list)
+    {
+        if (!enqueue(t, dry_run)) { return false; }
+    }
+    for (auto& t : list)
+    {
+        enqueue(t);
+    }
+    return true;
+}
+
+template<typename T>
+size_t LLTerrainQueue<T>::size() const
+{
+    return mList.size();
+}
+
+template<typename T>
+bool LLTerrainQueue<T>::empty() const
+{
+    return mList.empty();
+}
+
+template<typename T>
+void LLTerrainQueue<T>::clear()
+{
+    mList.clear();
+}
+
+void LLTerrainPaint::assert_confined_to(const LLTexture& tex) const
+{
+    llassert(mStartX >= 0 && mStartX < tex.getWidth());
+    llassert(mStartY >= 0 && mStartY < tex.getHeight());
+    llassert(mWidthX <= tex.getWidth() - mStartX);
+    llassert(mWidthY <= tex.getHeight() - mStartY);
+}
+
+void LLTerrainPaint::confine_to(const LLTexture& tex)
+{
+    mStartX = llmax(mStartX, 0);
+    mStartY = llmax(mStartY, 0);
+    mWidthX = llmin(mWidthX, tex.getWidth() - mStartX);
+    mWidthY = llmin(mWidthY, tex.getHeight() - mStartY);
+    assert_confined_to(tex);
+}
+
+LLTerrainPaintQueue::LLTerrainPaintQueue(U8 components)
+: mComponents(components)
+{
+    llassert(mComponents == LLTerrainPaint::RGB || mComponents == LLTerrainPaint::RGBA);
+}
+
+LLTerrainPaintQueue::LLTerrainPaintQueue(LLTerrainPaintQueue& other)
+: LLTerrainQueue<LLTerrainPaint>(other)
+, mComponents(other.mComponents)
+{
+    llassert(mComponents == LLTerrainPaint::RGB || mComponents == LLTerrainPaint::RGBA);
+}
+
+LLTerrainPaintQueue& LLTerrainPaintQueue::operator=(LLTerrainPaintQueue& other)
+{
+    LLTerrainQueue<LLTerrainPaint>::operator=(other);
+    mComponents = other.mComponents;
+    return *this;
+}
+
+bool LLTerrainPaintQueue::enqueue(LLTerrainPaint::ptr_t& paint, bool dry_run)
+{
+    llassert(paint);
+    if (!paint) { return false; }
+
+    // The paint struct should be pre-validated before this code is reached.
+    llassert(!paint->mData.empty());
+    // The internal paint map image is currently 8 bits, so that's the maximum
+    // allowed bit depth.
+    llassert(paint->mBitDepth > 0 && paint->mBitDepth <= 8);
+    llassert(paint->mData.size() == (mComponents * paint->mWidthX * paint->mWidthY));
+    llassert(paint->mWidthX > 0);
+    llassert(paint->mWidthY > 0);
+#ifdef SHOW_ASSERT
+    static LLCachedControl<U32> max_texture_width(gSavedSettings, "RenderMaxTextureResolution", 2048);
+#endif
+    llassert(paint->mWidthX <= max_texture_width);
+    llassert(paint->mWidthY <= max_texture_width);
+    llassert(paint->mStartX < max_texture_width);
+    llassert(paint->mStartY < max_texture_width);
+
+    return LLTerrainQueue<LLTerrainPaint>::enqueue(paint, dry_run);
+}
+
+bool LLTerrainPaintQueue::enqueue(LLTerrainPaintQueue& queue)
+{
+    return LLTerrainQueue<LLTerrainPaint>::enqueue(queue.mList);
+}
+
+void LLTerrainPaintQueue::convertBitDepths(size_t index, U8 target_bit_depth)
+{
+    llassert(target_bit_depth > 0 && target_bit_depth <= 8);
+    llassert(index < mList.size());
+
+    LLTerrainPaint::ptr_t& paint = mList[index];
+    if (paint->mBitDepth == target_bit_depth) { return; }
+
+    const F32 old_bit_max = F32((1 << paint->mBitDepth) - 1);
+    const F32 new_bit_max = F32((1 << target_bit_depth) - 1);
+    const F32 bit_conversion_factor = new_bit_max / old_bit_max;
+
+    for (U8& color : paint->mData)
+    {
+        color = (U8)llround(F32(color) * bit_conversion_factor);
+    }
+
+    paint->mBitDepth = target_bit_depth;
+}
+
+LLTerrainBrushQueue::LLTerrainBrushQueue()
+: LLTerrainQueue<LLTerrainBrush>()
+{
+}
+
+LLTerrainBrushQueue::LLTerrainBrushQueue(LLTerrainBrushQueue& other)
+: LLTerrainQueue<LLTerrainBrush>(other)
+{
+}
+
+LLTerrainBrushQueue& LLTerrainBrushQueue::operator=(LLTerrainBrushQueue& other)
+{
+    LLTerrainQueue<LLTerrainBrush>::operator=(other);
+    return *this;
+}
+
+bool LLTerrainBrushQueue::enqueue(LLTerrainBrush::ptr_t& brush, bool dry_run)
+{
+    llassert(brush->mBrushSize > 0);
+    llassert(!brush->mPath.empty());
+    llassert(brush->mPathOffset < brush->mPath.size());
+    llassert(brush->mPathOffset < 2); // Harmless, but doesn't do anything useful, so might be a sign of implementation error
+    return LLTerrainQueue<LLTerrainBrush>::enqueue(brush, dry_run);
+}
+
+bool LLTerrainBrushQueue::enqueue(LLTerrainBrushQueue& queue)
+{
+    return LLTerrainQueue<LLTerrainBrush>::enqueue(queue.mList);
+}
+
+template class LLTerrainQueue<LLTerrainPaint>;
+template class LLTerrainQueue<LLTerrainBrush>;
diff --git a/indra/newview/llterrainpaintmap.h b/indra/newview/llterrainpaintmap.h
index 66827862c5..d4859b747b 100644
--- a/indra/newview/llterrainpaintmap.h
+++ b/indra/newview/llterrainpaintmap.h
@@ -26,9 +26,20 @@
 
 #pragma once
 
+#include <memory>
+#include <vector>
+
+#include "stdtypes.h"
+#include "v2math.h"
+
+class LLTexture;
 class LLViewerRegion;
 class LLViewerTexture;
+class LLTerrainPaintQueue;
+class LLTerrainBrushQueue;
 
+// TODO: Terrain painting across regions. Assuming painting is confined to one
+// region for now.
 class LLTerrainPaintMap
 {
 public:
@@ -39,4 +50,121 @@ public:
     // to type TERRAIN_PAINT_TYPE_PBR_PAINTMAP.
     // Returns true if successful
     static bool bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& region, LLViewerTexture& tex);
+
+    // This operation clears the queue
+    // TODO: Decide if clearing the queue is needed - seems inconsistent
+    static void applyPaintQueueRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue);
+
+    static LLTerrainPaintQueue convertPaintQueueRGBAToRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue_in);
+    // TODO: Implement (it's similar to convertPaintQueueRGBAToRGB but different shader + need to calculate the dimensions + need a different vertex buffer for each brush stroke)
+    static LLTerrainPaintQueue convertBrushQueueToPaintRGB(const LLViewerRegion& region, LLViewerTexture& tex, LLTerrainBrushQueue& queue_in);
+};
+
+template<typename T>
+class LLTerrainQueue
+{
+public:
+    LLTerrainQueue() = default;
+    LLTerrainQueue(LLTerrainQueue<T>& other);
+    LLTerrainQueue& operator=(LLTerrainQueue<T>& other);
+
+    bool enqueue(std::shared_ptr<T>& t, bool dry_run = false);
+    size_t size() const;
+    bool empty() const;
+    void clear();
+
+    const std::vector<std::shared_ptr<T>>& get() const { return mList; }
+
+protected:
+    bool enqueue(std::vector<std::shared_ptr<T>>& list);
+
+    std::vector<std::shared_ptr<T>> mList;
+};
+
+// Enqueued paint operations, in texture coordinates.
+// mData is always RGB or RGBA (determined by mComponents), with each U8
+// storing one color with a max value of (1 >> mBitDepth) - 1
+struct LLTerrainPaint
+{
+    using ptr_t = std::shared_ptr<LLTerrainPaint>;
+
+    U16 mStartX;
+    U16 mStartY;
+    U16 mWidthX;
+    U16 mWidthY;
+    U8 mBitDepth;
+    U8 mComponents;
+    static constexpr U8 RGB = 3;
+    static constexpr U8 RGBA = 4;
+    std::vector<U8> mData;
+
+    // Asserts that this paint's start/width fit within the bounds of the
+    // provided texture dimensions.
+    void assert_confined_to(const LLTexture& tex) const;
+    // Confines this paint's start/width so it fits within the bounds of the
+    // provided texture dimensions.
+    // Does not allocate mData.
+    void confine_to(const LLTexture& tex);
+};
+
+class LLTerrainPaintQueue : public LLTerrainQueue<LLTerrainPaint>
+{
+public:
+    LLTerrainPaintQueue() = delete;
+    // components determines what type of LLTerrainPaint is allowed. Must be 3 (RGB) or 4 (RGBA)
+    LLTerrainPaintQueue(U8 components);
+    LLTerrainPaintQueue(LLTerrainPaintQueue& other);
+    LLTerrainPaintQueue& operator=(LLTerrainPaintQueue& other);
+
+    bool enqueue(LLTerrainPaint::ptr_t& paint, bool dry_run = false);
+    bool enqueue(LLTerrainPaintQueue& queue);
+
+    U8 getComponents() const { return mComponents; }
+    // Convert mBitDepth for the LLTerrainPaint in the queue at index
+    // If mBitDepth is already equal to target_bit_depth, no conversion takes
+    // place.
+    // It is currently the responsibility of the paint queue to convert
+    // incoming bits to the right bit depth for the paintmap (this could
+    // change in the future).
+    void convertBitDepths(size_t index, U8 target_bit_depth);
+
+private:
+    U8 mComponents;
+};
+
+struct LLTerrainBrush
+{
+    using ptr_t = std::shared_ptr<LLTerrainBrush>;
+
+    // Width of the brush in region space. The brush is a square texture with
+    // alpha.
+    F32 mBrushSize;
+    // Brush path points in region space, excluding the vertical axis, which
+    // does not contribute to the paint map.
+    std::vector<LLVector2> mPath;
+    // Offset of the brush path to actually start drawing at. An offset of 0
+    // indicates that a brush stroke has just started (i.e. the user just
+    // pressed down the mouse button). An offset greater than 0 indicates the
+    // continuation of a brush stroke. Skipped entries in mPath are not drawn
+    // directly, but are used for stroke orientation and path interpolation.
+    // TODO: For the initial implementation, mPathOffset will be 0 and mPath
+    // will be of length of at most 1, leading to discontinuous paint paths.
+    // Then, mPathOffset may be 1 or 0, 1 indicating the continuation of a
+    // stroke with linear interpolation. It is unlikely that we will implement
+    // anything more sophisticated than that for now.
+    U8 mPathOffset;
+    // Indicates if this is the end of the brush stroke. Can occur if the mouse
+    // button is lifted, or if the mouse temporarily stops while held down.
+    bool mPathEnd;
+};
+
+class LLTerrainBrushQueue : public LLTerrainQueue<LLTerrainBrush>
+{
+public:
+    LLTerrainBrushQueue();
+    LLTerrainBrushQueue(LLTerrainBrushQueue& other);
+    LLTerrainBrushQueue& operator=(LLTerrainBrushQueue& other);
+
+    bool enqueue(LLTerrainBrush::ptr_t& brush, bool dry_run = false);
+    bool enqueue(LLTerrainBrushQueue& queue);
 };
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index ee98728ff1..7b6f591254 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -2090,7 +2090,7 @@ bool LLTextureFetchWorker::deleteOK()
     // Allow any pending reads or writes to complete
     if (mCacheReadHandle != LLTextureCache::nullHandle())
     {
-        if (mFetcher->mTextureCache->readComplete(mCacheReadHandle, true))
+        if (!mFetcher->mTextureCache || mFetcher->mTextureCache->readComplete(mCacheReadHandle, true))
         {
             mCacheReadHandle = LLTextureCache::nullHandle();
         }
@@ -2101,7 +2101,7 @@ bool LLTextureFetchWorker::deleteOK()
     }
     if (mCacheWriteHandle != LLTextureCache::nullHandle())
     {
-        if (mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))
+        if (!mFetcher->mTextureCache || mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))
         {
             mCacheWriteHandle = LLTextureCache::nullHandle();
         }
diff --git a/indra/newview/lltoastgroupnotifypanel.cpp b/indra/newview/lltoastgroupnotifypanel.cpp
index 3c3440d41a..95653dc19b 100644
--- a/indra/newview/lltoastgroupnotifypanel.cpp
+++ b/indra/newview/lltoastgroupnotifypanel.cpp
@@ -87,10 +87,21 @@ LLToastGroupNotifyPanel::LLToastGroupNotifyPanel(const LLNotificationPtr& notifi
     std::string timeStr = "[" + LLTrans::getString("TimeWeek") + "], ["
                               + LLTrans::getString("TimeMonth") + "]/["
                               + LLTrans::getString("TimeDay") + "]/["
-                              + LLTrans::getString("TimeYear") + "] ["
-                              + LLTrans::getString("TimeHour") + "]:["
-                              + LLTrans::getString("TimeMin") + "] ["
-                              + LLTrans::getString("TimeTimezone") + "]";
+                              + LLTrans::getString("TimeYear") + "] [";
+    static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+    if (use_24h)
+    {
+        timeStr += LLTrans::getString("TimeHour") + "]:["
+            + LLTrans::getString("TimeMin") + "] ["
+            + LLTrans::getString("TimeTimezone") + "]";
+    }
+    else
+    {
+        timeStr += LLTrans::getString("TimeHour12") + "]:["
+            + LLTrans::getString("TimeMin") + "] ["
+            + LLTrans::getString("TimeAMPM") + "] ["
+            + LLTrans::getString("TimeTimezone") + "]";
+    }
 
     const LLDate timeStamp = notification->getDate();
     LLDate notice_date = timeStamp.notNull() ? timeStamp : payload["received_time"].asDate();
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index 865d7fd442..184c0e7d8b 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -76,6 +76,7 @@
 #include "llslurl.h"
 #include "llstartup.h"
 #include "llperfstats.h"
+#include "rlvcommon.h"
 
 // Third party library includes
 #include <boost/algorithm/string.hpp>
@@ -910,6 +911,7 @@ void settings_setup_listeners()
     setting_setup_signal_listener(gSavedSettings, "AutoTuneImpostorByDistEnabled", handleUserImpostorByDistEnabledChanged);
     setting_setup_signal_listener(gSavedSettings, "TuningFPSStrategy", handleFPSTuningStrategyChanged);
     {
+        setting_setup_signal_listener(gSavedSettings, "LocalTerrainPaintEnabled", handleSetShaderChanged);
         setting_setup_signal_listener(gSavedSettings, "LocalTerrainPaintEnabled", handleLocalTerrainChanged);
         const char* transform_suffixes[] = {
             "ScaleU",
@@ -932,6 +934,8 @@ void settings_setup_listeners()
     setting_setup_signal_listener(gSavedSettings, "TerrainPaintBitDepth", handleSetShaderChanged);
 
     setting_setup_signal_listener(gSavedPerAccountSettings, "AvatarHoverOffsetZ", handleAvatarHoverOffsetChanged);
+
+    setting_setup_signal_listener(gSavedSettings, Rlv::Settings::TopLevelMenu, Rlv::Util::menuToggleVisible);
 }
 
 #if TEST_CACHED_CONTROL
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 1f4502323c..cb741e4af9 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -79,6 +79,7 @@
 #include "llviewerparcelmgr.h"
 #include "llviewerregion.h"
 #include "llviewershadermgr.h"
+#include "llviewerstats.h"
 #include "llviewertexturelist.h"
 #include "llviewerwindow.h"
 #include "llvoavatarself.h"
@@ -1085,6 +1086,9 @@ void getProfileStatsContext(boost::json::object& stats)
         context.emplace("parcelid", parcel->getLocalID());
     }
     context.emplace("time", LLDate::now().toHTTPDateString("%Y-%m-%dT%H:%M:%S"));
+
+    // supplement with stats packet
+    stats.emplace("stats", LlsdToJson(capture_viewer_stats(true)));
 }
 
 std::string getProfileStatsFilename()
diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp
index 9d9961d51c..b2a7d875ab 100644
--- a/indra/newview/llviewerfloaterreg.cpp
+++ b/indra/newview/llviewerfloaterreg.cpp
@@ -176,6 +176,7 @@
 #include "llpreviewtexture.h"
 #include "llscriptfloater.h"
 #include "llsyswellwindow.h"
+#include "rlvfloaters.h"
 
 // *NOTE: Please add files in alphabetical order to keep merges easy.
 
@@ -483,6 +484,7 @@ void LLViewerFloaterReg::registerFloaters()
     LLFloaterReg::add("region_debug_console", "floater_region_debug_console.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterRegionDebugConsole>);
     LLFloaterReg::add("region_info", "floater_region_info.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterRegionInfo>);
     LLFloaterReg::add("region_restarting", "floater_region_restarting.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterRegionRestarting>);
+    LLFloaterReg::add("rlv_console", "floater_rlv_console.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<Rlv::FloaterConsole>);
 
     LLFloaterReg::add("script_debug", "floater_script_debug.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterScriptDebug>);
     LLFloaterReg::add("script_debug_output", "floater_script_debug_panel.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterScriptDebugOutput>);
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 39aa85beea..68c38c3692 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -117,6 +117,7 @@
 #include "lltoolmgr.h"
 #include "lltoolpie.h"
 #include "lltoolselectland.h"
+#include "llterrainpaintmap.h"
 #include "lltrans.h"
 #include "llviewerdisplay.h" //for gWindowResized
 #include "llviewergenericmessage.h"
@@ -151,6 +152,7 @@
 #include "llviewershadermgr.h"
 #include "gltfscenemanager.h"
 #include "gltf/asset.h"
+#include "rlvcommon.h"
 
 using namespace LLAvatarAppearanceDefines;
 
@@ -1428,16 +1430,21 @@ class LLAdvancedTerrainCreateLocalPaintMap : public view_listener_t
             return false;
         }
 
+        // This calls gLocalTerrainMaterials.setPaintType
+        // It also ensures the terrain bake shader is compiled (handleSetShaderChanged), so call this first
+        // *TODO: Fix compile errors in shader so it can be used for all platforms. Then we can unhide the shader from behind this setting and remove the hook to handleSetShaderChanged. This advanced setting is intended to be used as a local setting for testing terrain, not a feature flag, but it is currently used like a feature flag as a temporary hack.
+        // *TODO: Ideally we would call setPaintType *after* the paint map is well-defined. The terrain draw pool should be able to handle an undefined paint map in the meantime.
+        gSavedSettings.setBOOL("LocalTerrainPaintEnabled", true);
+
         U16 dim = (U16)gSavedSettings.getU32("TerrainPaintResolution");
         // Ensure a reasonable image size of power two
         const U32 max_resolution = gSavedSettings.getU32("RenderMaxTextureResolution");
         dim = llclamp(dim, 16, max_resolution);
         dim = 1 << U32(std::ceil(std::log2(dim)));
+        // TODO: Could probably get away with not using image raw here, now that we aren't writing bits via the CPU (see load_exr for example)
         LLPointer<LLImageRaw> image_raw = new LLImageRaw(dim,dim,3);
         LLPointer<LLViewerTexture> tex = LLViewerTextureManager::getLocalTexture(image_raw.get(), true);
         const bool success = LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(*region, *tex);
-        // This calls gLocalTerrainMaterials.setPaintType
-        gSavedSettings.setBOOL("LocalTerrainPaintEnabled", true);
         // If baking the paintmap failed, set the paintmap to nullptr. This
         // causes LLDrawPoolTerrain to use a blank paintmap instead.
         if (!success) { tex = nullptr; }
@@ -1447,6 +1454,92 @@ class LLAdvancedTerrainCreateLocalPaintMap : public view_listener_t
     }
 };
 
+class LLAdvancedTerrainEditLocalPaintMap : public view_listener_t
+{
+    bool handleEvent(const LLSD& userdata)
+    {
+        LLViewerTexture* tex = gLocalTerrainMaterials.getPaintMap();
+        if (!tex)
+        {
+            LL_WARNS() << "No local paint map available to edit" << LL_ENDL;
+            return false;
+        }
+
+        LLTerrainBrushQueue& brush_queue = gLocalTerrainMaterials.getBrushQueue();
+        LLTerrainPaintQueue& paint_request_queue = gLocalTerrainMaterials.getPaintRequestQueue();
+
+        const LLViewerRegion* region = gAgent.getRegion();
+        if (!region)
+        {
+            LL_WARNS() << "No current region for calculating paint operations" << LL_ENDL;
+            return false;
+        }
+        // TODO: Create the brush
+        // Just a dab for now
+        LLTerrainBrush::ptr_t brush = std::make_shared<LLTerrainBrush>();
+        brush->mBrushSize = 16.0f;
+        brush->mPath.emplace_back(17.0f, 17.0f);
+        brush->mPathOffset = 0;
+        brush->mPathEnd = true;
+        brush_queue.enqueue(brush);
+        LLTerrainPaintQueue brush_as_paint_queue = LLTerrainPaintMap::convertBrushQueueToPaintRGB(*region, *tex, brush_queue);
+        //paint_send_queue.enqueue(brush_as_paint_queue); // TODO: What was this line for? (it might also be a leftover line from an unfinished edit)
+
+        // TODO: Keep this around for later testing (i.e. when reducing framebuffer size and the offsets that requires)
+#if 0
+        // Enqueue a paint
+        // Modifies a subsection of the region paintmap with the material in
+        // the last slot.
+        // It is currently the responsibility of the paint queue to convert
+        // incoming bits to the right bit depth for the paintmap (this could
+        // change in the future).
+        LLTerrainPaint::ptr_t paint = std::make_shared<LLTerrainPaint>();
+        const U16 width = 33;
+        paint->mStartX = 1;
+        paint->mStartY = 1;
+        paint->mWidthX = width;
+        paint->mWidthY = width;
+        constexpr U8 bit_depth = 5;
+        paint->mBitDepth = bit_depth;
+        constexpr U8 max_value = (1 << bit_depth) - 1;
+        const size_t pixel_count = width * width;
+        const U8 components = LLTerrainPaint::RGBA;
+        paint->mComponents = components;
+        paint->mData.resize(components * pixel_count);
+        for (size_t h = 0; h < paint->mWidthY; ++h)
+        {
+            for (size_t w = 0; w < paint->mWidthX; ++w)
+            {
+                const size_t pixel = (h * paint->mWidthX) + w;
+                // Solid blue color
+                paint->mData[(components*pixel) + components - 2] = max_value; // blue
+                //// Alpha grid: 1.0 if odd for either dimension, 0.0 otherwise
+                //const U8 alpha = U8(F32(max_value) * F32(bool(w % 2) || bool(h % 2)));
+                //paint->mData[(components*pixel) + components - 1] = alpha; // alpha
+                // Alpha "frame"
+                const bool edge = w == 0 || h == 0 || w == (paint->mWidthX - 1) || h == (paint->mWidthY - 1);
+                const bool near_edge_frill = ((w == 1 || w == (paint->mWidthX - 2)) && (h % 2 == 0)) ||
+                                             ((h == 1 || h == (paint->mWidthY - 2)) && (w % 2 == 0));
+                const U8 alpha = U8(F32(max_value) * F32(edge || near_edge_frill));
+                paint->mData[(components*pixel) + components - 1] = alpha; // alpha
+            }
+        }
+        paint_request_queue.enqueue(paint);
+#endif
+
+        // Apply the paint queues ad-hoc right here for now.
+        // *TODO: Eventually the paint queue(s) should be applied at a
+        // predictable time in the viewer frame loop.
+        // TODO: In hindsight... maybe we *should* bind the paintmap to the render buffer. That makes a lot more sense, and we wouldn't have to reduce its resolution by settling for the bake buffer. If we do that, make a comment above convertPaintQueueRGBAToRGB that the texture is modified!
+        LLTerrainPaintQueue paint_send_queue = LLTerrainPaintMap::convertPaintQueueRGBAToRGB(*tex, paint_request_queue);
+        LLTerrainPaintQueue& paint_map_queue = gLocalTerrainMaterials.getPaintMapQueue();
+        paint_map_queue.enqueue(paint_send_queue);
+        LLTerrainPaintMap::applyPaintQueueRGB(*tex, paint_map_queue);
+
+        return true;
+    }
+};
+
 class LLAdvancedTerrainDeleteLocalPaintMap : public view_listener_t
 {
     bool handleEvent(const LLSD& userdata)
@@ -6280,6 +6373,8 @@ void show_debug_menus()
         gMenuBarView->setItemVisible("Advanced", debug);
 //      gMenuBarView->setItemEnabled("Advanced", debug); // Don't disable Advanced keyboard shortcuts when hidden
 
+        Rlv::Util::menuToggleVisible();
+
         gMenuBarView->setItemVisible("Debug", qamode);
         gMenuBarView->setItemEnabled("Debug", qamode);
 
@@ -7713,15 +7808,29 @@ class LLAvatarSendIM : public view_listener_t
 
 class LLAvatarCall : public view_listener_t
 {
+    static LLVOAvatar* findAvatar()
+    {
+        return find_avatar_from_object(LLSelectMgr::getInstance()->getSelection()->getPrimaryObject());
+    }
+
     bool handleEvent(const LLSD& userdata)
     {
-        LLVOAvatar* avatar = find_avatar_from_object( LLSelectMgr::getInstance()->getSelection()->getPrimaryObject() );
-        if(avatar)
+        if (LLVOAvatar* avatar = findAvatar())
         {
             LLAvatarActions::startCall(avatar->getID());
         }
         return true;
     }
+
+public:
+    static bool isAvailable()
+    {
+        if (LLVOAvatar* avatar = findAvatar())
+        {
+            return LLAvatarActions::canCallTo(avatar->getID());
+        }
+        return LLAvatarActions::canCall();
+    }
 };
 
 namespace
@@ -9624,8 +9733,6 @@ void initialize_menus()
     registrar.add("Agent.ToggleMicrophone", boost::bind(&LLAgent::toggleMicrophone, _2), cb_info::UNTRUSTED_BLOCK);
     enable.add("Agent.IsMicrophoneOn", boost::bind(&LLAgent::isMicrophoneOn, _2));
     enable.add("Agent.IsActionAllowed", boost::bind(&LLAgent::isActionAllowed, _2));
-    registrar.add("Agent.ToggleHearMediaSoundFromAvatar", boost::bind(&LLAgent::toggleHearMediaSoundFromAvatar), cb_info::UNTRUSTED_BLOCK);
-    registrar.add("Agent.ToggleHearVoiceFromAvatar", boost::bind(&LLAgent::toggleHearVoiceFromAvatar), cb_info::UNTRUSTED_BLOCK);
 
     // File menu
     init_menu_file();
@@ -9810,6 +9917,7 @@ void initialize_menus()
     // Develop > Terrain
     view_listener_t::addMenu(new LLAdvancedRebuildTerrain(), "Advanced.RebuildTerrain");
     view_listener_t::addMenu(new LLAdvancedTerrainCreateLocalPaintMap(), "Advanced.TerrainCreateLocalPaintMap");
+    view_listener_t::addMenu(new LLAdvancedTerrainEditLocalPaintMap(), "Advanced.TerrainEditLocalPaintMap");
     view_listener_t::addMenu(new LLAdvancedTerrainDeleteLocalPaintMap(), "Advanced.TerrainDeleteLocalPaintMap");
 
     // Advanced > UI
@@ -9981,7 +10089,7 @@ void initialize_menus()
     registrar.add("Avatar.ShowInspector", boost::bind(&handle_avatar_show_inspector));
     view_listener_t::addMenu(new LLAvatarSendIM(), "Avatar.SendIM");
     view_listener_t::addMenu(new LLAvatarCall(), "Avatar.Call", cb_info::UNTRUSTED_BLOCK);
-    enable.add("Avatar.EnableCall", boost::bind(&LLAvatarActions::canCall));
+    enable.add("Avatar.EnableCall", boost::bind(&LLAvatarCall::isAvailable));
     view_listener_t::addMenu(new LLAvatarReportAbuse(), "Avatar.ReportAbuse", cb_info::UNTRUSTED_THROTTLE);
     view_listener_t::addMenu(new LLAvatarToggleMyProfile(), "Avatar.ToggleMyProfile");
     view_listener_t::addMenu(new LLAvatarTogglePicks(), "Avatar.TogglePicks");
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index da019d60d8..33d9b5eb67 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -118,6 +118,8 @@
 #include "llpanelplaceprofile.h"
 #include "llviewerregion.h"
 #include "llfloaterregionrestarting.h"
+#include "rlvactions.h"
+#include "rlvhandler.h"
 
 #include "llnotificationmanager.h" //
 #include "llexperiencecache.h"
@@ -2382,15 +2384,16 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
     }
 
     bool is_audible = (CHAT_AUDIBLE_FULLY == chat.mAudible);
+    bool show_script_chat_particles = chat.mSourceType == CHAT_SOURCE_OBJECT
+        && chat.mChatType != CHAT_TYPE_DEBUG_MSG
+        && gSavedSettings.getBOOL("EffectScriptChatParticles");
     chatter = gObjectList.findObject(from_id);
     if (chatter)
     {
         chat.mPosAgent = chatter->getPositionAgent();
 
         // Make swirly things only for talking objects. (not script debug messages, though)
-        if (chat.mSourceType == CHAT_SOURCE_OBJECT
-            && chat.mChatType != CHAT_TYPE_DEBUG_MSG
-            && gSavedSettings.getBOOL("EffectScriptChatParticles") )
+        if (show_script_chat_particles && (!RlvActions::isRlvEnabled() || CHAT_TYPE_OWNER != chat.mChatType) )
         {
             LLPointer<LLViewerPartSourceChat> psc = new LLViewerPartSourceChat(chatter->getPositionAgent());
             psc->setSourceObject(chatter);
@@ -2482,8 +2485,25 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
             case CHAT_TYPE_SHOUT:
                 prefix += LLTrans::getString("shout") + " ";
                 break;
-            case CHAT_TYPE_DEBUG_MSG:
             case CHAT_TYPE_OWNER:
+                if (RlvActions::isRlvEnabled())
+                {
+                    if (RlvHandler::instance().handleSimulatorChat(mesg, chat, chatter))
+                    {
+                        break;
+                    }
+                    else if (show_script_chat_particles)
+                    {
+                        LLPointer<LLViewerPartSourceChat> psc = new LLViewerPartSourceChat(chatter->getPositionAgent());
+                        psc->setSourceObject(chatter);
+                        psc->setColor(color);
+                        //We set the particles to be owned by the object's owner,
+                        //just in case they should be muted by the mute list
+                        psc->setOwnerUUID(owner_id);
+                        LLViewerPartSim::getInstance()->addPartSource(psc);
+                    }
+                }
+            case CHAT_TYPE_DEBUG_MSG:
             case CHAT_TYPE_NORMAL:
             case CHAT_TYPE_DIRECT:
                 break;
@@ -6623,7 +6643,6 @@ void process_initiate_download(LLMessageSystem* msg, void**)
         (void**)new std::string(viewer_filename));
 }
 
-
 void process_script_teleport_request(LLMessageSystem* msg, void**)
 {
     if (!gSavedSettings.getBOOL("ScriptsCanShowUI")) return;
@@ -6637,6 +6656,11 @@ void process_script_teleport_request(LLMessageSystem* msg, void**)
     msg->getString("Data", "SimName", sim_name);
     msg->getVector3("Data", "SimPosition", pos);
     msg->getVector3("Data", "LookAt", look_at);
+    U32 flags = (BEACON_SHOW_MAP | BEACON_FOCUS_MAP);
+    if (msg->has("Options"))
+    {
+        msg->getU32("Options", "Flags", flags);
+    }
 
     LLFloaterWorldMap* instance = LLFloaterWorldMap::getInstance();
     if(instance)
@@ -6647,7 +6671,13 @@ void process_script_teleport_request(LLMessageSystem* msg, void**)
             << LL_ENDL;
 
         instance->trackURL(sim_name, (S32)pos.mV[VX], (S32)pos.mV[VY], (S32)pos.mV[VZ]);
-        LLFloaterReg::showInstance("world_map", "center");
+        if (flags & BEACON_SHOW_MAP)
+        {
+            bool old_auto_focus = instance->getAutoFocus();
+            instance->setAutoFocus(flags & BEACON_FOCUS_MAP);
+            instance->openFloater("center");
+            instance->setAutoFocus(old_auto_focus);
+        }
     }
 
     // remove above two lines and replace with below line
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 88e5d900cb..739821d2f5 100755
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -3155,7 +3155,7 @@ void LLViewerRegion::unpackRegionHandshake()
         std::string cap = getCapability("ModifyRegion"); // needed for queueQuery
         if (cap.empty())
         {
-            LLFloaterRegionInfo::sRefreshFromRegion(this);
+            LLFloaterRegionInfo::refreshFromRegion(this);
         }
         else
         {
@@ -3167,7 +3167,7 @@ void LLViewerRegion::unpackRegionHandshake()
                 LLVLComposition* compp = region->getComposition();
                 if (!compp) { return; }
                 compp->apply(composition_changes);
-                LLFloaterRegionInfo::sRefreshFromRegion(region);
+                LLFloaterRegionInfo::refreshFromRegion(region);
             });
         }
     }
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index a8fe221d98..a6d397c039 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -100,6 +100,7 @@ LLGLSLShader    gReflectionProbeDisplayProgram;
 LLGLSLShader    gCopyProgram;
 LLGLSLShader    gCopyDepthProgram;
 LLGLSLShader    gPBRTerrainBakeProgram;
+LLGLSLShader    gTerrainStampProgram;
 
 //object shaders
 LLGLSLShader        gObjectPreviewProgram;
@@ -3170,6 +3171,34 @@ bool LLViewerShaderMgr::loadShadersInterface()
         }
     }
 
+    if (gSavedSettings.getBOOL("LocalTerrainPaintEnabled"))
+    {
+        if (success)
+        {
+            LLGLSLShader* shader = &gTerrainStampProgram;
+            U32 bit_depth = gSavedSettings.getU32("TerrainPaintBitDepth");
+            // LLTerrainPaintMap currently uses an RGB8 texture internally
+            bit_depth = llclamp(bit_depth, 1, 8);
+            shader->mName = llformat("Terrain Stamp Shader RGB%o", bit_depth);
+
+            shader->mShaderFiles.clear();
+            shader->mShaderFiles.push_back(make_pair("interface/terrainStampV.glsl", GL_VERTEX_SHADER));
+            shader->mShaderFiles.push_back(make_pair("interface/terrainStampF.glsl", GL_FRAGMENT_SHADER));
+            shader->mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+            const U32 value_range = (1 << bit_depth) - 1;
+            shader->addPermutation("TERRAIN_PAINT_PRECISION", llformat("%d", value_range));
+            success = success && shader->createShader();
+            //llassert(success);
+            if (!success)
+            {
+                LL_WARNS() << "Failed to create shader '" << shader->mName << "', disabling!" << LL_ENDL;
+                gSavedSettings.setBOOL("RenderCanUseTerrainBakeShaders", false);
+                // continue as if this shader never happened
+                success = true;
+            }
+        }
+    }
+
     if (success)
     {
         gAlphaMaskProgram.mName = "Alpha Mask Shader";
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index b08796025a..e654967c46 100644
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -175,6 +175,7 @@ extern LLGLSLShader         gReflectionProbeDisplayProgram;
 extern LLGLSLShader         gCopyProgram;
 extern LLGLSLShader         gCopyDepthProgram;
 extern LLGLSLShader         gPBRTerrainBakeProgram;
+extern LLGLSLShader         gTerrainStampProgram;
 
 //output tex0[tc0] - tex1[tc1]
 extern LLGLSLShader         gTwoTextureCompareProgram;
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index 9d4c072909..a4b06b1e1a 100644
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -67,6 +67,7 @@
 #include "lluiusage.h"
 #include "lltranslate.h"
 #include "llluamanager.h"
+#include "scope_exit.h"
 
 // "Minimal Vulkan" to get max API Version
 
@@ -510,7 +511,6 @@ void send_viewer_stats(bool include_preferences)
         return;
     }
 
-    LLSD body;
     std::string url = gAgent.getRegion()->getCapability("ViewerStats");
 
     if (url.empty()) {
@@ -518,8 +518,18 @@ void send_viewer_stats(bool include_preferences)
         return;
     }
 
-    LLViewerStats::instance().getRecording().pause();
+    LLSD body = capture_viewer_stats(include_preferences);
+    LLCoreHttpUtil::HttpCoroutineAdapter::messageHttpPost(url, body,
+        "Statistics posted to sim", "Failed to post statistics to sim");
+}
+
+LLSD capture_viewer_stats(bool include_preferences)
+{
+    LLViewerStats& vstats{ LLViewerStats::instance() };
+    vstats.getRecording().pause();
+    LL::scope_exit cleanup([&vstats]{ vstats.getRecording().resume(); });
 
+    LLSD body;
     LLSD &agent = body["agent"];
 
     time_t ltime;
@@ -791,10 +801,7 @@ void send_viewer_stats(bool include_preferences)
     body["session_id"] = gAgentSessionID;
 
     LLViewerStats::getInstance()->addToMessage(body);
-
-    LLCoreHttpUtil::HttpCoroutineAdapter::messageHttpPost(url, body,
-        "Statistics posted to sim", "Failed to post statistics to sim");
-    LLViewerStats::instance().getRecording().resume();
+    return body;
 }
 
 LLTimer& LLViewerStats::PhaseMap::getPhaseTimer(const std::string& phase_name)
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index 8aed1c537e..dd66fee436 100644
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -281,6 +281,7 @@ static const F32 SEND_STATS_PERIOD = 300.0f;
 
 // The following are from (older?) statistics code found in appviewer.
 void update_statistics();
+LLSD capture_viewer_stats(bool include_preferences);
 void send_viewer_stats(bool include_preferences);
 void update_texture_time();
 
diff --git a/indra/newview/llviewerwindowlistener.cpp b/indra/newview/llviewerwindowlistener.cpp
index 52f413792a..45b4da0aac 100644
--- a/indra/newview/llviewerwindowlistener.cpp
+++ b/indra/newview/llviewerwindowlistener.cpp
@@ -35,6 +35,7 @@
 // std headers
 // external library headers
 // other Linden headers
+#include "llcallbacklist.h"
 #include "llviewerwindow.h"
 
 LLViewerWindowListener::LLViewerWindowListener(LLViewerWindow* llviewerwindow):
@@ -46,8 +47,7 @@ LLViewerWindowListener::LLViewerWindowListener(LLViewerWindow* llviewerwindow):
     add("saveSnapshot",
         "Save screenshot: [\"filename\"] (extension may be specified: bmp, jpeg, png)\n"
         "[\"width\"], [\"height\"], [\"showui\"], [\"showhud\"], [\"rebuild\"], [\"type\"]\n"
-        "type: \"COLOR\", \"DEPTH\"\n"
-        "Post on [\"reply\"] an event containing [\"result\"]",
+        "type: \"COLOR\", \"DEPTH\"\n",
         &LLViewerWindowListener::saveSnapshot,
         llsd::map("filename", LLSD::String(), "reply", LLSD()));
     add("requestReshape",
@@ -57,8 +57,6 @@ LLViewerWindowListener::LLViewerWindowListener(LLViewerWindow* llviewerwindow):
 
 void LLViewerWindowListener::saveSnapshot(const LLSD& event) const
 {
-    Response response(LLSD(), event);
-
     typedef std::map<LLSD::String, LLSnapshotModel::ESnapshotLayerType> TypeMap;
     TypeMap types;
 #define tp(name) types[#name] = LLSnapshotModel::SNAPSHOT_TYPE_##name
@@ -88,7 +86,8 @@ void LLViewerWindowListener::saveSnapshot(const LLSD& event) const
         TypeMap::const_iterator found = types.find(event["type"]);
         if (found == types.end())
         {
-            return response.error(stringize("Unrecognized type ", std::quoted(event["type"].asString()), " [\"COLOR\"] or [\"DEPTH\"] is expected."));
+            sendReply(llsd::map("error", stringize("Unrecognized type ", std::quoted(event["type"].asString()), " [\"COLOR\"] or [\"DEPTH\"] is expected.")), event);
+            return;
         }
         type = found->second;
     }
@@ -96,7 +95,8 @@ void LLViewerWindowListener::saveSnapshot(const LLSD& event) const
     std::string filename(event["filename"]);
     if (filename.empty())
     {
-        return response.error(stringize("File path is empty."));
+        sendReply(llsd::map("error", stringize("File path is empty.")), event);
+        return;
     }
 
     LLSnapshotModel::ESnapshotFormat format(LLSnapshotModel::SNAPSHOT_FORMAT_BMP);
@@ -115,9 +115,13 @@ void LLViewerWindowListener::saveSnapshot(const LLSD& event) const
     }
     else if (ext != "bmp")
     {
-        return response.error(stringize("Unrecognized format. [\"png\"], [\"jpeg\"] or [\"bmp\"] is expected."));
+        sendReply(llsd::map("error", stringize("Unrecognized format. [\"png\"], [\"jpeg\"] or [\"bmp\"] is expected.")), event);
+        return;
     }
-    response["result"] = mViewerWindow->saveSnapshot(filename, width, height, showui, showhud, rebuild, type, format);
+    // take snapshot on the main coro
+    doOnIdleOneTime([this, event, filename, width, height, showui, showhud, rebuild, type, format]()
+                    { sendReply(llsd::map("result", mViewerWindow->saveSnapshot(filename, width, height, showui, showhud, rebuild, type, format)), event); });
+
 }
 
 void LLViewerWindowListener::requestReshape(LLSD const & event_data) const
diff --git a/indra/newview/llvlcomposition.cpp b/indra/newview/llvlcomposition.cpp
index 077e6e6cb1..ca76d93cd7 100644
--- a/indra/newview/llvlcomposition.cpp
+++ b/indra/newview/llvlcomposition.cpp
@@ -320,7 +320,11 @@ LLViewerTexture* LLTerrainMaterials::getPaintMap()
 void LLTerrainMaterials::setPaintMap(LLViewerTexture* paint_map)
 {
     llassert(!paint_map || mPaintType == TERRAIN_PAINT_TYPE_PBR_PAINTMAP);
+    const bool changed = paint_map != mPaintMap;
     mPaintMap = paint_map;
+    // The paint map has changed, so edits are no longer valid
+    mPaintRequestQueue.clear();
+    mPaintMapQueue.clear();
 }
 
 // Boost the texture loading priority
diff --git a/indra/newview/llvlcomposition.h b/indra/newview/llvlcomposition.h
index f15f9bff6a..21fd484375 100644
--- a/indra/newview/llvlcomposition.h
+++ b/indra/newview/llvlcomposition.h
@@ -31,6 +31,7 @@
 #include "llviewershadermgr.h"
 #include "llviewertexture.h"
 #include "llpointer.h"
+#include "llterrainpaintmap.h"
 
 #include "llimage.h"
 
@@ -87,6 +88,18 @@ public:
     void setPaintType(U32 paint_type) { mPaintType = paint_type; }
     LLViewerTexture* getPaintMap();
     void setPaintMap(LLViewerTexture* paint_map);
+    // Queue of client-triggered brush operations that need to be converted
+    // into a form that can be sent to the server.
+    // TODO: Consider getting rid of mPaintRequestQueue, as it's not really needed (brushes go directly to RGB queue)
+    LLTerrainBrushQueue& getBrushQueue() { return mBrushQueue; }
+    // Queue of client-triggered paint operations that need to be converted
+    // into a form that can be sent to the server.
+    // Paints in this queue are in RGBA format.
+    LLTerrainPaintQueue& getPaintRequestQueue() { return mPaintRequestQueue; }
+    // Paint queue for current paint map - this queue gets applied directly to
+    // the paint map. Paints within are assumed to have already been sent to
+    // the server.  Paints in this queue are in RGB format.
+    LLTerrainPaintQueue& getPaintMapQueue() { return mPaintMapQueue; }
 
 protected:
     void unboost();
@@ -105,6 +118,9 @@ protected:
 
     U32 mPaintType = TERRAIN_PAINT_TYPE_HEIGHTMAP_WITH_NOISE;
     LLPointer<LLViewerTexture> mPaintMap;
+    LLTerrainBrushQueue mBrushQueue;
+    LLTerrainPaintQueue mPaintRequestQueue{U8(4)};
+    LLTerrainPaintQueue mPaintMapQueue{U8(3)};
 };
 
 // Local materials to override all regions
diff --git a/indra/newview/llvoiceclient.cpp b/indra/newview/llvoiceclient.cpp
index 1a35a71706..243cba6ffd 100644
--- a/indra/newview/llvoiceclient.cpp
+++ b/indra/newview/llvoiceclient.cpp
@@ -391,12 +391,21 @@ void LLVoiceClient::setRenderDevice(const std::string& name)
     LLWebRTCVoiceClient::getInstance()->setRenderDevice(name);
 }
 
+bool LLVoiceClient::isCaptureNoDevice()
+{
+    return LLWebRTCVoiceClient::getInstance()->isCaptureNoDevice();
+}
+
+bool LLVoiceClient::isRenderNoDevice()
+{
+    return LLWebRTCVoiceClient::getInstance()->isRenderNoDevice();
+}
+
 const LLVoiceDeviceList& LLVoiceClient::getCaptureDevices()
 {
     return LLWebRTCVoiceClient::getInstance()->getCaptureDevices();
 }
 
-
 const LLVoiceDeviceList& LLVoiceClient::getRenderDevices()
 {
     return LLWebRTCVoiceClient::getInstance()->getRenderDevices();
diff --git a/indra/newview/llvoiceclient.h b/indra/newview/llvoiceclient.h
index d53f512d82..2731b0cc7f 100644
--- a/indra/newview/llvoiceclient.h
+++ b/indra/newview/llvoiceclient.h
@@ -192,6 +192,9 @@ public:
     virtual LLVoiceDeviceList& getCaptureDevices()=0;
     virtual LLVoiceDeviceList& getRenderDevices()=0;
 
+    virtual bool isCaptureNoDevice() = 0;
+    virtual bool isRenderNoDevice() = 0;
+
     virtual void getParticipantList(std::set<LLUUID> &participants)=0;
     virtual bool isParticipant(const LLUUID& speaker_id)=0;
     //@}
@@ -392,6 +395,8 @@ public:
 
     void setCaptureDevice(const std::string& name);
     void setRenderDevice(const std::string& name);
+    bool isCaptureNoDevice();
+    bool isRenderNoDevice();
     void setHidden(bool hidden);
 
     const LLVoiceDeviceList& getCaptureDevices();
diff --git a/indra/newview/llvoicevisualizer.cpp b/indra/newview/llvoicevisualizer.cpp
index 7691ac54f3..c5704982b8 100644
--- a/indra/newview/llvoicevisualizer.cpp
+++ b/indra/newview/llvoicevisualizer.cpp
@@ -337,7 +337,7 @@ void LLVoiceVisualizer::lipSyncOohAah( F32& ooh, F32& aah )
 //---------------------------------------------------
 void LLVoiceVisualizer::render()
 {
-    static LLCachedControl<bool> show_visualizer(gSavedSettings, "VoiceVisualizerEnabled", false);
+    static LLCachedControl<bool> show_visualizer(gSavedSettings, "VoiceVisualizerEnabled", true);
     if (!mVoiceEnabled || !show_visualizer)
     {
         return;
diff --git a/indra/newview/llvoicevivox.cpp b/indra/newview/llvoicevivox.cpp
index 4659fa5f71..b8ddc1f255 100644
--- a/indra/newview/llvoicevivox.cpp
+++ b/indra/newview/llvoicevivox.cpp
@@ -2775,6 +2775,7 @@ void LLVivoxVoiceClient::setCaptureDevice(const std::string& name)
         }
     }
 }
+
 void LLVivoxVoiceClient::setDevicesListUpdated(bool state)
 {
     mDevicesListUpdated = state;
@@ -6637,13 +6638,13 @@ void LLVivoxVoiceClient::expireVoiceFonts()
         }
     }
 
-    LLSD args;
-    args["URL"] = LLTrans::getString("voice_morphing_url");
-    args["PREMIUM_URL"] = LLTrans::getString("premium_voice_morphing_url");
-
     // Give a notification if any voice fonts have expired.
     if (have_expired)
     {
+        LLSD args;
+        args["URL"] = LLTrans::getString("voice_morphing_url");
+        args["PREMIUM_URL"] = LLTrans::getString("premium_voice_morphing_url");
+
         if (expired_in_use)
         {
             LLNotificationsUtil::add("VoiceEffectsExpiredInUse", args);
diff --git a/indra/newview/llvoicevivox.h b/indra/newview/llvoicevivox.h
index 3167705528..cec8b71442 100644
--- a/indra/newview/llvoicevivox.h
+++ b/indra/newview/llvoicevivox.h
@@ -121,6 +121,9 @@ public:
     void setCaptureDevice(const std::string& name) override;
     void setRenderDevice(const std::string& name) override;
 
+    bool isCaptureNoDevice() override { return false; };
+    bool isRenderNoDevice() override { return false; };
+
     LLVoiceDeviceList& getCaptureDevices() override;
     LLVoiceDeviceList& getRenderDevices() override;
     //@}
diff --git a/indra/newview/llvoicewebrtc.cpp b/indra/newview/llvoicewebrtc.cpp
index 4da348d090..6d4f3fe356 100644
--- a/indra/newview/llvoicewebrtc.cpp
+++ b/indra/newview/llvoicewebrtc.cpp
@@ -203,6 +203,7 @@ LLWebRTCVoiceClient::LLWebRTCVoiceClient() :
     mTuningMode(false),
     mTuningMicGain(0.0),
     mTuningSpeakerVolume(50),  // Set to 50 so the user can hear themselves when he sets his mic volume
+    mDeviceSettingsAvailable(false),
     mDevicesListUpdated(false),
 
     mSpatialCoordsDirty(false),
@@ -218,7 +219,7 @@ LLWebRTCVoiceClient::LLWebRTCVoiceClient() :
     mAvatarNameCacheConnection(),
     mIsInTuningMode(false),
     mIsProcessingChannels(false),
-    mIsCoroutineActive(false),
+    mIsTimerActive(false),
     mWebRTCPump("WebRTCClientPump"),
     mWebRTCDeviceInterface(nullptr)
 {
@@ -295,6 +296,20 @@ void LLWebRTCVoiceClient::cleanUp()
     mNeighboringRegions.clear();
     sessionState::for_each(boost::bind(predShutdownSession, _1));
     LL_DEBUGS("Voice") << "Exiting" << LL_ENDL;
+    stopTimer();
+}
+
+void LLWebRTCVoiceClient::stopTimer()
+{
+    if (mIsTimerActive)
+    {
+        LLMuteList::instanceExists();
+        {
+            LLMuteList::getInstance()->removeObserver(this);
+        }
+        mIsTimerActive = false;
+        LL::Timers::instance().cancel(mVoiceTimerHandle);
+    }
 }
 
 void LLWebRTCVoiceClient::LogMessage(llwebrtc::LLWebRTCLogCallback::LogLevel level, const std::string& message)
@@ -443,8 +458,7 @@ void LLWebRTCVoiceClient::removeObserver(LLFriendObserver *observer)
 
 //---------------------------------------------------
 // Primary voice loop.
-// This voice loop is called every 100ms plus the time it
-// takes to process the various functions called in the loop
+// This voice loop is called every 100ms
 // The loop does the following:
 // * gates whether we do channel processing depending on
 //   whether we're running a WebRTC voice channel or
@@ -456,100 +470,92 @@ void LLWebRTCVoiceClient::removeObserver(LLFriendObserver *observer)
 //   connection to various voice channels.
 // * Sends updates to the voice server when this agent's
 //   voice levels, or positions have changed.
-void LLWebRTCVoiceClient::voiceConnectionCoro()
+void LLWebRTCVoiceClient::connectionTimer()
 {
-    LL_DEBUGS("Voice") << "starting" << LL_ENDL;
-    mIsCoroutineActive = true;
-    LLCoros::set_consuming(true);
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_VOICE;
     try
     {
-        LLMuteList::getInstance()->addObserver(this);
-        while (!sShuttingDown)
-        {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_VOICE("voiceConnectionCoroLoop")
-            // TODO: Doing some measurement and calculation here,
-            // we could reduce the timeout to take into account the
-            // time spent on the previous loop to have the loop
-            // cycle at exactly 100ms, instead of 100ms + loop
-            // execution time.
-            // Could help with voice updates making for smoother
-            // voice when we're busy.
-            llcoro::suspendUntilTimeout(UPDATE_THROTTLE_SECONDS);
-            if (sShuttingDown) return; // 'this' migh already be invalid
-            bool voiceEnabled = mVoiceEnabled;
-
-            if (!isAgentAvatarValid())
+        bool voiceEnabled = mVoiceEnabled;
+
+        if (!isAgentAvatarValid())
+        {
+            if (sShuttingDown)
             {
-                continue;
+                cleanUp();
             }
+            return;
+        }
 
-            LLViewerRegion *regionp = gAgent.getRegion();
-            if (!regionp)
+        LLViewerRegion* regionp = gAgent.getRegion();
+        if (!regionp)
+        {
+            if (sShuttingDown)
             {
-                continue;
+                cleanUp();
             }
+            return;
+        }
 
-            if (!mProcessChannels)
+        if (!mProcessChannels)
+        {
+            // we've switched away from webrtc voice, so shut all channels down.
+            // leave channel can be called again and again without adverse effects.
+            // it merely tells channels to shut down if they're not already doing so.
+            leaveChannel(false);
+        }
+        else if (inSpatialChannel())
+        {
+            bool useEstateVoice = true;
+            // add session for region or parcel voice.
+            if (!regionp || regionp->getRegionID().isNull())
             {
-                // we've switched away from webrtc voice, so shut all channels down.
-                // leave channel can be called again and again without adverse effects.
-                // it merely tells channels to shut down if they're not already doing so.
-                leaveChannel(false);
+                // no region, no voice.
+                return;
             }
-            else if (inSpatialChannel())
-            {
-                bool useEstateVoice = true;
-                // add session for region or parcel voice.
-                if (!regionp || regionp->getRegionID().isNull())
-                {
-                    // no region, no voice.
-                    continue;
-                }
 
-                voiceEnabled = voiceEnabled && regionp->isVoiceEnabled();
+            voiceEnabled = voiceEnabled && regionp->isVoiceEnabled();
 
-                if (voiceEnabled)
+            if (voiceEnabled)
+            {
+                LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+                // check to see if parcel changed.
+                if (parcel && parcel->getLocalID() != INVALID_PARCEL_ID)
                 {
-                    LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-                    // check to see if parcel changed.
-                    if (parcel && parcel->getLocalID() != INVALID_PARCEL_ID)
+                    // parcel voice
+                    if (!parcel->getParcelFlagAllowVoice())
                     {
-                        // parcel voice
-                        if (!parcel->getParcelFlagAllowVoice())
-                        {
-                            voiceEnabled = false;
-                        }
-                        else if (!parcel->getParcelFlagUseEstateVoiceChannel())
-                        {
-                            // use the parcel-specific voice channel.
-                            S32         parcel_local_id = parcel->getLocalID();
-                            std::string channelID       = regionp->getRegionID().asString() + "-" + std::to_string(parcel->getLocalID());
-
-                            useEstateVoice = false;
-                            if (!inOrJoiningChannel(channelID))
-                            {
-                                startParcelSession(channelID, parcel_local_id);
-                            }
-                        }
+                        voiceEnabled = false;
                     }
-                    if (voiceEnabled && useEstateVoice && !inEstateChannel())
+                    else if (!parcel->getParcelFlagUseEstateVoiceChannel())
                     {
-                        // estate voice
-                        startEstateSession();
+                        // use the parcel-specific voice channel.
+                        S32         parcel_local_id = parcel->getLocalID();
+                        std::string channelID = regionp->getRegionID().asString() + "-" + std::to_string(parcel->getLocalID());
+
+                        useEstateVoice = false;
+                        if (!inOrJoiningChannel(channelID))
+                        {
+                            startParcelSession(channelID, parcel_local_id);
+                        }
                     }
                 }
-                if (!voiceEnabled)
+                if (voiceEnabled && useEstateVoice && !inEstateChannel())
                 {
-                    // voice is disabled, so leave and disable PTT
-                    leaveChannel(true);
-                }
-                else
-                {
-                    // we're in spatial voice, and voice is enabled, so determine positions in order
-                    // to send position updates.
-                    updatePosition();
+                    // estate voice
+                    startEstateSession();
                 }
             }
+            if (!voiceEnabled)
+            {
+                // voice is disabled, so leave and disable PTT
+                leaveChannel(true);
+            }
+            else
+            {
+                // we're in spatial voice, and voice is enabled, so determine positions in order
+                // to send position updates.
+                updatePosition();
+            }
             LL::WorkQueue::postMaybe(mMainQueue,
                 [=, this] {
                     if  (sShuttingDown)
@@ -565,10 +571,6 @@ void LLWebRTCVoiceClient::voiceConnectionCoro()
             });
         }
     }
-    catch (const LLCoros::Stop&)
-    {
-        LL_DEBUGS("LLWebRTCVoiceClient") << "Received a shutdown exception" << LL_ENDL;
-    }
     catch (const LLContinueError&)
     {
         LOG_UNHANDLED_EXCEPTION("LLWebRTCVoiceClient");
@@ -582,7 +584,10 @@ void LLWebRTCVoiceClient::voiceConnectionCoro()
         throw;
     }
 
-    cleanUp();
+    if (sShuttingDown)
+    {
+        cleanUp();
+    }
 }
 
 // For spatial, determine which neighboring regions to connect to
@@ -640,12 +645,14 @@ void LLWebRTCVoiceClient::leaveAudioSession()
 void LLWebRTCVoiceClient::clearCaptureDevices()
 {
     LL_DEBUGS("Voice") << "called" << LL_ENDL;
+    mDeviceSettingsAvailable = false;
     mCaptureDevices.clear();
 }
 
 void LLWebRTCVoiceClient::addCaptureDevice(const LLVoiceDevice& device)
 {
     LL_INFOS("Voice") << "Voice Capture Device: '" << device.display_name << "' (" << device.full_name << ")" << LL_ENDL;
+    mDeviceSettingsAvailable = false;
     mCaptureDevices.push_back(device);
 }
 
@@ -658,6 +665,7 @@ void LLWebRTCVoiceClient::setCaptureDevice(const std::string& name)
 {
     mWebRTCDeviceInterface->setCaptureDevice(name);
 }
+
 void LLWebRTCVoiceClient::setDevicesListUpdated(bool state)
 {
     mDevicesListUpdated = state;
@@ -703,20 +711,22 @@ void LLWebRTCVoiceClient::OnDevicesChangedImpl(const llwebrtc::LLWebRTCVoiceDevi
     }
     setCaptureDevice(inputDevice);
 
+    mDeviceSettingsAvailable = true;
     setDevicesListUpdated(true);
 }
 
 void LLWebRTCVoiceClient::clearRenderDevices()
 {
     LL_DEBUGS("Voice") << "called" << LL_ENDL;
+    mDeviceSettingsAvailable = false;
     mRenderDevices.clear();
 }
 
 void LLWebRTCVoiceClient::addRenderDevice(const LLVoiceDevice& device)
 {
     LL_INFOS("Voice") << "Voice Render Device: '" << device.display_name << "' (" << device.full_name << ")" << LL_ENDL;
+    mDeviceSettingsAvailable = false;
     mRenderDevices.push_back(device);
-
 }
 
 LLVoiceDeviceList& LLWebRTCVoiceClient::getRenderDevices()
@@ -729,6 +739,16 @@ void LLWebRTCVoiceClient::setRenderDevice(const std::string& name)
     mWebRTCDeviceInterface->setRenderDevice(name);
 }
 
+bool LLWebRTCVoiceClient::isCaptureNoDevice()
+{
+    return mCaptureDevices.empty() || mWebRTCDeviceInterface->isCaptureNoDevice();
+}
+
+bool LLWebRTCVoiceClient::isRenderNoDevice()
+{
+    return mRenderDevices.empty() || mWebRTCDeviceInterface->isRenderNoDevice();
+}
+
 void LLWebRTCVoiceClient::tuningStart()
 {
     if (!mIsInTuningMode)
@@ -754,11 +774,15 @@ bool LLWebRTCVoiceClient::inTuningMode()
 
 void LLWebRTCVoiceClient::tuningSetMicVolume(float volume)
 {
-    mTuningMicGain      = volume;
+    mTuningMicGain = volume;
 }
 
 void LLWebRTCVoiceClient::tuningSetSpeakerVolume(float volume)
 {
+    if (isRenderNoDevice())
+    {
+        volume = 0;
+    }
 
     if (volume != mTuningSpeakerVolume)
     {
@@ -768,14 +792,17 @@ void LLWebRTCVoiceClient::tuningSetSpeakerVolume(float volume)
 
 float LLWebRTCVoiceClient::getAudioLevel()
 {
-    if (mIsInTuningMode)
+    if (isCaptureNoDevice())
     {
-        return (1.0f - mWebRTCDeviceInterface->getTuningAudioLevel() * LEVEL_SCALE_WEBRTC) * mTuningMicGain / 2.1f;
+        return 0;
     }
-    else
+
+    if (mIsInTuningMode)
     {
-        return (1.0f - mWebRTCDeviceInterface->getPeerConnectionAudioLevel() * LEVEL_SCALE_WEBRTC) * mMicGain / 2.1f;
+        return (1.0f - mWebRTCDeviceInterface->getTuningAudioLevel() * LEVEL_SCALE_WEBRTC) * mTuningMicGain / 2.1f;
     }
+
+    return (1.0f - mWebRTCDeviceInterface->getPeerConnectionAudioLevel() * LEVEL_SCALE_WEBRTC) * mMicGain / 2.1f;
 }
 
 float LLWebRTCVoiceClient::tuningGetEnergy(void)
@@ -783,15 +810,6 @@ float LLWebRTCVoiceClient::tuningGetEnergy(void)
     return getAudioLevel();
 }
 
-bool LLWebRTCVoiceClient::deviceSettingsAvailable()
-{
-    bool result = true;
-
-    if(mRenderDevices.empty() || mCaptureDevices.empty())
-        result = false;
-
-    return result;
-}
 bool LLWebRTCVoiceClient::deviceSettingsUpdated()
 {
     bool updated = mDevicesListUpdated;
@@ -801,7 +819,7 @@ bool LLWebRTCVoiceClient::deviceSettingsUpdated()
 
 void LLWebRTCVoiceClient::refreshDeviceLists(bool clearCurrentList)
 {
-    if(clearCurrentList)
+    if (clearCurrentList)
     {
         clearCaptureDevices();
         clearRenderDevices();
@@ -809,7 +827,6 @@ void LLWebRTCVoiceClient::refreshDeviceLists(bool clearCurrentList)
     mWebRTCDeviceInterface->refreshDevices();
 }
 
-
 void LLWebRTCVoiceClient::setHidden(bool hidden)
 {
     mHidden = hidden;
@@ -1340,7 +1357,7 @@ bool LLWebRTCVoiceClient::isVoiceWorking() const
     // webrtc is working if the coroutine is active in the case of
     // webrtc. WebRTC doesn't need to connect to a secondary process
     // or a login server to become active.
-    return mIsCoroutineActive;
+    return mIsTimerActive;
 }
 
 // Returns true if calling back the session URI after the session has closed is possible.
@@ -1523,9 +1540,7 @@ void LLWebRTCVoiceClient::setVoiceVolume(F32 volume)
 {
     if (volume != mSpeakerVolume)
     {
-        {
-            mSpeakerVolume      = volume;
-        }
+        mSpeakerVolume  = volume;
         sessionState::for_each(boost::bind(predSetSpeakerVolume, _1, volume));
     }
 }
@@ -1544,7 +1559,6 @@ void LLWebRTCVoiceClient::setMicGain(F32 gain)
     }
 }
 
-
 void LLWebRTCVoiceClient::setVoiceEnabled(bool enabled)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_VOICE;
@@ -1552,7 +1566,7 @@ void LLWebRTCVoiceClient::setVoiceEnabled(bool enabled)
     LL_DEBUGS("Voice")
         << "( " << (enabled ? "enabled" : "disabled") << " )"
         << " was "<< (mVoiceEnabled ? "enabled" : "disabled")
-        << " coro "<< (mIsCoroutineActive ? "active" : "inactive")
+        << " coro "<< (mIsTimerActive ? "active" : "inactive")
         << LL_ENDL;
 
     if (enabled != mVoiceEnabled)
@@ -1569,10 +1583,12 @@ void LLWebRTCVoiceClient::setVoiceEnabled(bool enabled)
             status = LLVoiceClientStatusObserver::STATUS_VOICE_ENABLED;
             mSpatialCoordsDirty = true;
             updatePosition();
-            if (!mIsCoroutineActive)
+            if (!mIsTimerActive)
             {
-                LLCoros::instance().launch("LLWebRTCVoiceClient::voiceConnectionCoro",
-                    boost::bind(&LLWebRTCVoiceClient::voiceConnectionCoro, LLWebRTCVoiceClient::getInstance()));
+                LL_DEBUGS("Voice") << "Starting" << LL_ENDL;
+                mIsTimerActive = true;
+                LLMuteList::getInstance()->addObserver(this);
+                mVoiceTimerHandle = LL::Timers::instance().scheduleEvery([this]() { connectionTimer(); return false; }, UPDATE_THROTTLE_SECONDS);
             }
             else
             {
diff --git a/indra/newview/llvoicewebrtc.h b/indra/newview/llvoicewebrtc.h
index ff82d2739d..88ead98950 100644
--- a/indra/newview/llvoicewebrtc.h
+++ b/indra/newview/llvoicewebrtc.h
@@ -30,6 +30,7 @@ class LLWebRTCProtocolParser;
 
 #include "lliopipe.h"
 #include "llpumpio.h"
+#include "llcallbacklist.h"
 #include "llchainio.h"
 #include "lliosocket.h"
 #include "v3math.h"
@@ -113,7 +114,7 @@ public:
     /// @name Devices
     //@{
     // This returns true when it's safe to bring up the "device settings" dialog in the prefs.
-    bool deviceSettingsAvailable() override;
+    bool deviceSettingsAvailable() override { return mDeviceSettingsAvailable; }
     bool deviceSettingsUpdated() override;  //return if the list has been updated and never fetched,  only to be called from the voicepanel.
 
     // Requery the WebRTC daemon for the current list of input/output devices.
@@ -125,6 +126,9 @@ public:
     void setCaptureDevice(const std::string& name) override;
     void setRenderDevice(const std::string& name) override;
 
+    bool isCaptureNoDevice() override;
+    bool isRenderNoDevice() override;
+
     LLVoiceDeviceList& getCaptureDevices() override;
     LLVoiceDeviceList& getRenderDevices() override;
     //@}
@@ -447,19 +451,23 @@ private:
 
     // Coroutine support methods
     //---
-    void voiceConnectionCoro();
+    void connectionTimer();
 
     //---
     /// Clean up objects created during a voice session.
     void cleanUp();
 
+    // stop state machine
+    void stopTimer();
+
     LL::WorkQueue::weak_t mMainQueue;
 
     bool mTuningMode;
     F32 mTuningMicGain;
     int mTuningSpeakerVolume;
+    bool mDeviceSettingsAvailable;
     bool mDevicesListUpdated;            // set to true when the device list has been updated
-                                        // and false when the panelvoicedevicesettings has queried for an update status.
+                                         // and false when the panelvoicedevicesettings has queried for an update status.
     std::string mSpatialSessionCredentials;
 
     std::string mMainSessionGroupHandle; // handle of the "main" session group.
@@ -534,7 +542,8 @@ private:
 
     bool    mIsInTuningMode;
     bool    mIsProcessingChannels;
-    bool    mIsCoroutineActive;
+    bool    mIsTimerActive;
+    LL::Timers::handle_t mVoiceTimerHandle;
 
     // These variables can last longer than WebRTC in coroutines so we need them as static
     static bool sShuttingDown;
diff --git a/indra/newview/llworldmap.cpp b/indra/newview/llworldmap.cpp
index 7962c28e6d..2fd45337fc 100644
--- a/indra/newview/llworldmap.cpp
+++ b/indra/newview/llworldmap.cpp
@@ -32,6 +32,7 @@
 #include "message.h"
 #include "lltracker.h"
 #include "lluistring.h"
+#include "llviewercontrol.h"
 #include "llviewertexturelist.h"
 #include "lltrans.h"
 #include "llgltexture.h"
@@ -117,6 +118,7 @@ LLVector3d LLSimInfo::getGlobalOrigin() const
 {
     return from_region_handle(mHandle);
 }
+
 LLVector3 LLSimInfo::getLocalPos(LLVector3d global_pos) const
 {
     LLVector3d sim_origin = from_region_handle(mHandle);
@@ -492,9 +494,20 @@ bool LLWorldMap::insertItem(U32 x_world, U32 y_world, std::string& name, LLUUID&
         case MAP_ITEM_MATURE_EVENT:
         case MAP_ITEM_ADULT_EVENT:
         {
-            std::string timeStr = "["+ LLTrans::getString ("TimeHour")+"]:["
-                                       +LLTrans::getString ("TimeMin")+"] ["
-                                       +LLTrans::getString ("TimeAMPM")+"]";
+            std::string timeStr;
+
+            static bool use_24h = gSavedSettings.getBOOL("Use24HourClock");
+            if (use_24h)
+            {
+                std::string timeStr = "[" + LLTrans::getString("TimeHour") + "]:["
+                    + LLTrans::getString("TimeMin") + "]";
+            }
+            else
+            {
+                std::string timeStr = "[" + LLTrans::getString("TimeHour12") + "]:["
+                    + LLTrans::getString("TimeMin") + "] ["
+                    + LLTrans::getString("TimeAMPM") + "]";
+            }
             LLSD substitution;
             substitution["datetime"] = (S32) extra;
             LLStringUtil::format (timeStr, substitution);
diff --git a/indra/newview/llworldmapview.cpp b/indra/newview/llworldmapview.cpp
index 6b2bd3e6fb..1be6a6cfff 100755
--- a/indra/newview/llworldmapview.cpp
+++ b/indra/newview/llworldmapview.cpp
@@ -517,26 +517,38 @@ void LLWorldMapView::draw()
         // Draw the region name in the lower left corner
         if (mMapScale >= DRAW_TEXT_THRESHOLD)
         {
-            std::string mesg;
+            static LLCachedControl<bool> print_coords(gSavedSettings, "MapShowGridCoords");
+            static LLFontGL* font = LLFontGL::getFontSansSerifSmallBold();
+
+            auto print = [&](std::string text, F32 x, F32 y, bool use_ellipses)
+                {
+                    font->renderUTF8(text, 0,
+                        (F32)llfloor(left + x), (F32)llfloor(bottom + y),
+                        LLColor4::white,
+                        LLFontGL::LEFT, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW,
+                        S32_MAX, //max_chars
+                        (S32)mMapScale, //max_pixels
+                        NULL,
+                        use_ellipses);
+                };
+
+            std::string grid_name = info->getName();
             if (info->isDown())
             {
-                mesg = llformat( "%s (%s)", info->getName().c_str(), sStringsMap["offline"].c_str());
+                grid_name += " (" + sStringsMap["offline"] + ")";
             }
-            else
+
+            if (print_coords)
             {
-                mesg = info->getName();
+                print(grid_name, 3, 14, true);
+                // Obtain and print the grid map coordinates
+                LLVector3d region_pos = info->getGlobalOrigin();
+                std::string grid_coords = llformat("[%.0f, %.0f]", region_pos[VX] / 256, region_pos[VY] / 256);
+                print(grid_coords, 3, 2, false);
             }
-            if (!mesg.empty())
+            else
             {
-                LLFontGL::getFontSansSerifSmallBold()->renderUTF8(
-                    mesg, 0,
-                    (F32)llfloor(left + 3), (F32)llfloor(bottom + 2),
-                    LLColor4::white,
-                    LLFontGL::LEFT, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW,
-                    S32_MAX, //max_chars
-                    (S32)mMapScale, //max_pixels
-                    NULL,
-                    /*use_ellipses*/true);
+                print(grid_name, 3, 2, true);
             }
         }
     }
diff --git a/indra/newview/rlvactions.cpp b/indra/newview/rlvactions.cpp
new file mode 100644
index 0000000000..110beeafc0
--- /dev/null
+++ b/indra/newview/rlvactions.cpp
@@ -0,0 +1,42 @@
+/**
+ * @file rlvactions.cpp
+ * @author Kitty Barnett
+ * @brief RLVa public facing helper class to easily make RLV checks
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "rlvactions.h"
+#include "rlvhandler.h"
+
+// ============================================================================
+// Helper functions
+//
+
+bool RlvActions::isRlvEnabled()
+{
+    return RlvHandler::isEnabled();
+}
+
+// ============================================================================
diff --git a/indra/newview/rlvactions.h b/indra/newview/rlvactions.h
new file mode 100644
index 0000000000..cb0df95e37
--- /dev/null
+++ b/indra/newview/rlvactions.h
@@ -0,0 +1,46 @@
+/**
+ * @file rlvactions.h
+ * @author Kitty Barnett
+ * @brief RLVa public facing helper class to easily make RLV checks
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+// ============================================================================
+// RlvActions - developer-friendly non-RLVa code facing class, use in lieu of RlvHandler whenever possible
+//
+
+class RlvActions
+{
+    // ================
+    // Helper functions
+    // ================
+public:
+    /*
+     * Convenience function to check if RLVa is enabled without having to include rlvhandler.h
+     */
+    static bool isRlvEnabled();
+};
+
+// ============================================================================
diff --git a/indra/newview/rlvcommon.cpp b/indra/newview/rlvcommon.cpp
new file mode 100644
index 0000000000..4140659715
--- /dev/null
+++ b/indra/newview/rlvcommon.cpp
@@ -0,0 +1,134 @@
+/**
+ * @file rlvcommon.h
+ * @author Kitty Barnett
+ * @brief RLVa helper functions and constants used throughout the viewer
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llagent.h"
+#include "llchat.h"
+#include "lldbstrings.h"
+#include "llversioninfo.h"
+#include "llviewermenu.h"
+#include "llviewerstats.h"
+#include "message.h"
+#include <boost/algorithm/string.hpp>
+
+#include "rlvcommon.h"
+
+#include "llviewercontrol.h"
+#include "rlvhandler.h"
+
+using namespace Rlv;
+
+// ============================================================================
+// RlvStrings
+//
+
+std::string Strings::getVersion(bool wants_legacy)
+{
+    return llformat("%s viewer v%d.%d.%d (RLVa %d.%d.%d)",
+        !wants_legacy ? "RestrainedLove" : "RestrainedLife",
+        SpecVersion::Major, SpecVersion::Minor, SpecVersion::Patch,
+        ImplVersion::Major, ImplVersion::Minor, ImplVersion::Patch);
+}
+
+std::string Strings::getVersionAbout()
+{
+    return llformat("RLV v%d.%d.%d / RLVa v%d.%d.%d.%d",
+        SpecVersion::Major, SpecVersion::Minor, SpecVersion::Patch,
+        ImplVersion::Major, ImplVersion::Minor, ImplVersion::Patch, LLVersionInfo::instance().getBuild());
+}
+
+std::string Strings::getVersionNum()
+{
+    return llformat("%d%02d%02d%02d",
+        SpecVersion::Major, SpecVersion::Minor, SpecVersion::Patch, SpecVersion::Build);
+}
+
+std::string Strings::getVersionImplNum()
+{
+    return llformat("%d%02d%02d%02d",
+        ImplVersion::Major, ImplVersion::Minor, ImplVersion::Patch, ImplVersion::ImplId);
+}
+
+// ============================================================================
+// RlvUtil
+//
+
+void Util::menuToggleVisible()
+{
+    bool isTopLevel = gSavedSettings.getBOOL(Settings::TopLevelMenu);
+    bool isRlvEnabled = RlvHandler::isEnabled();
+
+    LLMenuGL* menuRLVaMain = gMenuBarView->findChildMenuByName("RLVa Main", false);
+    LLMenuGL* menuAdvanced = gMenuBarView->findChildMenuByName("Advanced", false);
+    LLMenuGL* menuRLVaEmbed= menuAdvanced->findChildMenuByName("RLVa Embedded", false);
+
+    gMenuBarView->setItemVisible("RLVa Main", isRlvEnabled && isTopLevel);
+    menuAdvanced->setItemVisible("RLVa Embedded", isRlvEnabled && !isTopLevel);
+
+    if ( isRlvEnabled && menuRLVaMain && menuRLVaEmbed &&
+         ( (isTopLevel && 1 == menuRLVaMain->getItemCount()) || (!isTopLevel && 1 == menuRLVaEmbed->getItemCount())) )
+    {
+        LLMenuGL* menuFrom = isTopLevel ? menuRLVaEmbed : menuRLVaMain;
+        LLMenuGL* menuTo = isTopLevel ? menuRLVaMain : menuRLVaEmbed;
+        while (LLMenuItemGL* pItem = menuFrom->getItem(1))
+        {
+            menuFrom->removeChild(pItem);
+            menuTo->addChild(pItem);
+            pItem->updateBranchParent(menuTo);
+        }
+    }
+}
+
+bool Util::parseStringList(const std::string& strInput, std::vector<std::string>& optionList, std::string_view strSeparator)
+{
+    if (!strInput.empty())
+        boost::split(optionList, strInput, boost::is_any_of(strSeparator));
+    return !optionList.empty();
+}
+
+bool Util::sendChatReply(S32 nChannel, const std::string& strUTF8Text)
+{
+    if (!isValidReplyChannel(nChannel))
+        return false;
+
+    // Copy/paste from send_chat_from_viewer()
+    gMessageSystem->newMessageFast(_PREHASH_ChatFromViewer);
+    gMessageSystem->nextBlockFast(_PREHASH_AgentData);
+    gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+    gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+    gMessageSystem->nextBlockFast(_PREHASH_ChatData);
+    gMessageSystem->addStringFast(_PREHASH_Message, utf8str_truncate(strUTF8Text, MAX_MSG_STR_LEN));
+    gMessageSystem->addU8Fast(_PREHASH_Type, CHAT_TYPE_SHOUT);
+    gMessageSystem->addS32("Channel", nChannel);
+    gAgent.sendReliableMessage();
+    add(LLStatViewer::CHAT_COUNT, 1);
+
+    return true;
+}
+
+// ============================================================================
diff --git a/indra/newview/rlvcommon.h b/indra/newview/rlvcommon.h
new file mode 100644
index 0000000000..6f1bbbbdc6
--- /dev/null
+++ b/indra/newview/rlvcommon.h
@@ -0,0 +1,72 @@
+/**
+ * @file rlvcommon.h
+ * @author Kitty Barnett
+ * @brief RLVa helper functions and constants used throughout the viewer
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+#include "rlvdefines.h"
+
+namespace Rlv
+{
+    // ============================================================================
+    // RlvStrings
+    //
+
+    class Strings
+    {
+    public:
+        static std::string        getVersion(bool wants_legacy);
+        static std::string        getVersionAbout();
+        static std::string        getVersionImplNum();
+        static std::string        getVersionNum();
+    };
+
+    // ============================================================================
+    // RlvUtil
+    //
+
+    namespace Util
+    {
+        bool isValidReplyChannel(S32 nChannel, bool isLoopback = false);
+        void menuToggleVisible();
+        bool parseStringList(const std::string& strInput, std::vector<std::string>& optionList, std::string_view strSeparator = Constants::OptionSeparator);
+        bool sendChatReply(S32 nChannel, const std::string& strUTF8Text);
+        bool sendChatReply(const std::string& strChannel, const std::string& strUTF8Text);
+    };
+
+    inline bool Util::isValidReplyChannel(S32 nChannel, bool isLoopback)
+    {
+        return (nChannel > (!isLoopback ? 0 : -1)) && (CHAT_CHANNEL_DEBUG != nChannel);
+    }
+
+    inline bool Util::sendChatReply(const std::string& strChannel, const std::string& strUTF8Text)
+    {
+        S32 nChannel;
+        return LLStringUtil::convertToS32(strChannel, nChannel) ? sendChatReply(nChannel, strUTF8Text) : false;
+    }
+
+    // ============================================================================
+}
diff --git a/indra/newview/rlvdefines.h b/indra/newview/rlvdefines.h
new file mode 100644
index 0000000000..e39328fdd6
--- /dev/null
+++ b/indra/newview/rlvdefines.h
@@ -0,0 +1,194 @@
+/**
+ * @file rlvdefines.h
+ * @author Kitty Barnett
+ * @brief RLVa common defines, constants and enums
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+// ============================================================================
+// Defines
+//
+
+// Defining these makes it easier if we ever need to change our tag
+#define RLV_WARNS		LL_WARNS("RLV")
+#define RLV_INFOS		LL_INFOS("RLV")
+#define RLV_DEBUGS		LL_DEBUGS("RLV")
+#define RLV_ENDL		LL_ENDL
+#define RLV_VERIFY(f)	(f)
+
+#if LL_RELEASE_WITH_DEBUG_INFO || LL_DEBUG
+    // Make sure we halt execution on errors
+    #define RLV_ERRS				LL_ERRS("RLV")
+    // Keep our asserts separate from LL's
+    #define RLV_ASSERT(f)			if (!(f)) { RLV_ERRS << "ASSERT (" << #f << ")" << RLV_ENDL; }
+    #define RLV_ASSERT_DBG(f)		RLV_ASSERT(f)
+#else
+    // Don't halt execution on errors in release
+    #define RLV_ERRS				LL_WARNS("RLV")
+    // We don't want to check assertions in release builds
+    #ifdef RLV_DEBUG
+        #define RLV_ASSERT(f)		RLV_VERIFY(f)
+        #define RLV_ASSERT_DBG(f)
+    #else
+        #define RLV_ASSERT(f)
+        #define RLV_ASSERT_DBG(f)
+    #endif // RLV_DEBUG
+#endif // LL_RELEASE_WITH_DEBUG_INFO || LL_DEBUG
+
+namespace Rlv
+{
+    // Version of the specification we report
+    namespace SpecVersion {
+        constexpr S32 Major = 4;
+        constexpr S32 Minor = 0;
+        constexpr S32 Patch = 0;
+        constexpr S32 Build = 0;
+    };
+
+    // RLVa implementation version
+    namespace ImplVersion {
+        constexpr S32 Major = 3;
+        constexpr S32 Minor = 0;
+        constexpr S32 Patch = 0;
+        constexpr S32 ImplId = 13;
+    };
+
+    namespace Constants
+    {
+        constexpr char CmdPrefix = '@';
+        constexpr char ConsolePrompt[] = "> ";
+        constexpr std::string_view OptionSeparator = ";";
+    }
+}
+
+// ============================================================================
+// Enumeration declarations
+//
+
+namespace Rlv
+{
+    enum class EBehaviour {
+        Version = 0,
+        VersionNew,
+        VersionNum,
+        GetCommand,
+
+        Count,
+        Unknown,
+    };
+
+    enum class EBehaviourOptionType
+    {
+        EmptyOrException,                   // Behaviour takes no parameters
+        Exception,                          // Behaviour requires an exception as a parameter
+        NoneOrException,                    // Behaviour takes either no parameters or an exception
+    };
+
+    enum class EParamType {
+        Unknown = 0x00,
+        Add     = 0x01,                 // <param> == "n"|"add"
+        Remove  = 0x02,                 // <param> == "y"|"rem"
+        Force   = 0x04,                 // <param> == "force"
+        Reply   = 0x08,                 // <param> == <number>
+        Clear   = 0x10,
+        AddRem  = Add | Remove
+    };
+
+    enum class ECmdRet {
+        Unknown = 0x0000,               // Unknown error (should only be used internally)
+        Retained,                       // Command was retained
+        Succeeded = 0x0100,             // Command executed successfully
+        SuccessUnset,                   // Command executed successfully (RLV_TYPE_REMOVE for an unrestricted behaviour)
+        SuccessDuplicate,               // Command executed successfully (RLV_TYPE_ADD for an already restricted behaviour)
+        SuccessDeprecated,              // Command executed successfully but has been marked as deprecated
+        SuccessDelayed,                 // Command parsed valid but will execute at a later time
+        Failed = 0x0200,                // Command failed (general failure)
+        FailedSyntax,                   // Command failed (syntax error)
+        FailedOption,                   // Command failed (invalid option)
+        FailedParam,                    // Command failed (invalid param)
+        FailedLock,                     // Command failed (command is locked by another object)
+        FailedDisabled,                 // Command failed (command disabled by user)
+        FailedUnknown,                  // Command failed (unknown command)
+        FailedNoSharedRoot,             // Command failed (missing #RLV)
+        FailedDeprecated,               // Command failed (deprecated and no longer supported)
+        FailedNoBehaviour,              // Command failed (force modifier on an object with no active restrictions)
+        FailedUnheldBehaviour,          // Command failed (local modifier on an object that doesn't hold the base behaviour)
+        FailedBlocked,                  // Command failed (object is blocked)
+        FailedThrottled,                // Command failed (throttled)
+        FailedNoProcessor               // Command doesn't have a template processor define (legacy code)
+    };
+
+    enum class EExceptionCheck
+    {
+        Permissive,						// Exception can be set by any object
+        Strict,							// Exception must be set by all objects holding the restriction
+        Default,						// Permissive or strict will be determined by currently enforced restrictions
+    };
+
+    // Replace&remove in c++23
+    template <typename E>
+    constexpr std::enable_if_t<std::is_enum_v<E> && !std::is_convertible_v<E, int>, std::underlying_type_t<E>> to_underlying(E e) noexcept
+    {
+        return static_cast<std::underlying_type_t<E>>(e);
+    }
+
+    template <typename E>
+    constexpr std::enable_if_t<std::is_enum_v<E> && !std::is_convertible_v<E, int>, bool> has_flag(E value, E flag) noexcept
+    {
+        return (to_underlying(value) & to_underlying(flag)) != 0;
+    }
+
+    constexpr bool isReturnCodeSuccess(ECmdRet eRet)
+    {
+        return (to_underlying(eRet) & to_underlying(ECmdRet::Succeeded)) == to_underlying(ECmdRet::Succeeded);
+    }
+
+    constexpr bool isReturnCodeFailed(ECmdRet eRet)
+    {
+        return (to_underlying(eRet) & to_underlying(ECmdRet::Failed)) == to_underlying(ECmdRet::Failed);
+    }
+}
+
+// ============================================================================
+// Settings
+//
+
+namespace Rlv
+{
+    namespace Settings
+    {
+        constexpr char Main[] = "RestrainedLove";
+        constexpr char Debug[] = "RestrainedLoveDebug";
+
+        constexpr char DebugHideUnsetDup[] = "RLVaDebugHideUnsetDuplicate";
+        constexpr char EnableExperimentalCommands[] = "RLVaExperimentalCommands";
+        constexpr char EnableIMQuery[] = "RLVaEnableIMQuery";
+        constexpr char EnableTempAttach[] = "RLVaEnableTemporaryAttachments";
+        constexpr char TopLevelMenu[] = "RLVaTopLevelMenu";
+    };
+
+};
+
+// ============================================================================
diff --git a/indra/newview/rlvfloaters.cpp b/indra/newview/rlvfloaters.cpp
new file mode 100644
index 0000000000..8a074fd14d
--- /dev/null
+++ b/indra/newview/rlvfloaters.cpp
@@ -0,0 +1,122 @@
+/**
+ * @file rlvfloaters.cpp
+ * @author Kitty Barnett
+ * @brief RLVa floaters class implementations
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llagentdata.h"
+#include "llchatentry.h"
+#include "lltexteditor.h"
+#include "lltrans.h"
+#include "llvoavatarself.h"
+
+#include "rlvfloaters.h"
+#include "rlvhandler.h"
+
+using namespace Rlv;
+
+// ============================================================================
+// FloaterConsole
+//
+
+bool FloaterConsole::postBuild()
+{
+    mInputEdit = getChild<LLChatEntry>("console_input");
+    mInputEdit->setCommitCallback(std::bind(&FloaterConsole::onInput, this));
+    mInputEdit->setTextExpandedCallback(std::bind(&FloaterConsole::reshapeLayoutPanel, this));
+    mInputEdit->setFocus(true);
+    mInputEdit->setCommitOnFocusLost(false);
+
+    mInputPanel = getChild<LLLayoutPanel>("input_panel");
+    mInputEditPad = mInputPanel->getRect().getHeight() - mInputEdit->getRect().getHeight();
+
+    mOutputText = getChild<LLTextEditor>("console_output");
+    mOutputText->appendText(Constants::ConsolePrompt, false);
+
+    if (RlvHandler::isEnabled())
+    {
+        mCommandOutputConn = RlvHandler::instance().setCommandOutputCallback([this](const RlvCommand& rlvCmd, S32, const std::string strText)
+        {
+            if (rlvCmd.getObjectID() == gAgentID)
+            {
+                mOutputText->appendText(rlvCmd.getBehaviour() + ": ", true);
+                mOutputText->appendText(strText, false);
+            }
+        });
+    }
+
+    return true;
+}
+
+void FloaterConsole::onClose(bool fQuitting)
+{
+    if (RlvHandler::isEnabled())
+    {
+        RlvHandler::instance().processCommand(gAgentID, "clear", true);
+    }
+}
+
+void FloaterConsole::onInput()
+{
+    if (!isAgentAvatarValid())
+    {
+        return;
+    }
+
+    std::string strText = mInputEdit->getText();
+    LLStringUtil::trim(strText);
+
+    mOutputText->appendText(strText, false);
+    mInputEdit->setText(LLStringUtil::null);
+
+    if (!RlvHandler::isEnabled())
+    {
+        mOutputText->appendText(LLTrans::getString("RlvConsoleDisable"), true);
+    }
+    else if (strText.length() <= 3 || Constants::CmdPrefix != strText[0])
+    {
+        mOutputText->appendText(LLTrans::getString("RlvConsoleInvalidCmd"), true);
+    }
+    else
+    {
+        LLChat chat;
+        chat.mFromID = gAgentID;
+        chat.mChatType = CHAT_TYPE_OWNER;
+
+        RlvHandler::instance().handleSimulatorChat(strText, chat, gAgentAvatarp);
+
+        mOutputText->appendText(strText, true);
+    }
+
+    mOutputText->appendText(Constants::ConsolePrompt, true);
+}
+
+void FloaterConsole::reshapeLayoutPanel()
+{
+    mInputPanel->reshape(mInputPanel->getRect().getWidth(), mInputEdit->getRect().getHeight() + mInputEditPad, false);
+}
+
+// ============================================================================
diff --git a/indra/newview/rlvfloaters.h b/indra/newview/rlvfloaters.h
new file mode 100644
index 0000000000..8acfa43f28
--- /dev/null
+++ b/indra/newview/rlvfloaters.h
@@ -0,0 +1,68 @@
+/**
+ * @file rlvfloaters.h
+ * @author Kitty Barnett
+ * @brief RLVa floaters class implementations
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+#include "llfloater.h"
+
+#include "rlvdefines.h"
+
+class LLChatEntry;
+class LLFloaterReg;
+class LLLayoutPanel;
+class LLTextEditor;
+class RlvCommand;
+class RlvHandler;
+
+namespace Rlv
+{
+    // ============================================================================
+    // FloaterConsole - debug console to allow command execution without the need for a script
+    //
+
+    class FloaterConsole : public LLFloater
+    {
+        friend class ::LLFloaterReg;
+        FloaterConsole(const LLSD& sdKey) : LLFloater(sdKey) {}
+
+    public:
+        bool postBuild() override;
+        void onClose(bool fQuitting) override;
+    protected:
+        void onInput();
+        void reshapeLayoutPanel();
+
+    private:
+        boost::signals2::scoped_connection mCommandOutputConn;
+        int mInputEditPad = 0;
+        LLLayoutPanel* mInputPanel = nullptr;
+        LLChatEntry* mInputEdit = nullptr;
+        LLTextEditor* mOutputText = nullptr;
+    };
+
+    // ============================================================================
+};
diff --git a/indra/newview/rlvhandler.cpp b/indra/newview/rlvhandler.cpp
new file mode 100644
index 0000000000..6c4b439105
--- /dev/null
+++ b/indra/newview/rlvhandler.cpp
@@ -0,0 +1,225 @@
+/**
+ * @file rlvhandler.cpp
+ * @author Kitty Barnett
+ * @brief RLVa helper classes for internal use only
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+#include "llagent.h"
+#include "llstartup.h"
+#include "llviewercontrol.h"
+#include "llviewerobject.h"
+
+#include "rlvcommon.h"
+#include "rlvhandler.h"
+#include "rlvhelper.h"
+
+#include <boost/algorithm/string.hpp>
+
+using namespace Rlv;
+
+// ============================================================================
+// Static variable initialization
+//
+
+bool RlvHandler::mIsEnabled = false;
+
+// ============================================================================
+// Command processing functions
+//
+
+bool RlvHandler::handleSimulatorChat(std::string& message, const LLChat& chat, const LLViewerObject* chatObj)
+{
+    // *TODO: There's an edge case for temporary attachments when going from enabled -> disabled with restrictions already in place
+    static LLCachedControl<bool> enable_temp_attach(gSavedSettings, Settings::EnableTempAttach);
+    static LLCachedControl<bool> show_debug_output(gSavedSettings, Settings::Debug);
+    static LLCachedControl<bool> hide_unset_dupes(gSavedSettings, Settings::DebugHideUnsetDup);
+
+    if ( message.length() <= 3 || Constants::CmdPrefix != message[0] || CHAT_TYPE_OWNER != chat.mChatType ||
+         (chatObj && chatObj->isTempAttachment() && !enable_temp_attach()) )
+    {
+        return false;
+    }
+
+    message.erase(0, 1);
+    LLStringUtil::toLower(message);
+    CommandDbgOut cmdDbgOut(message, chatObj->getID() == gAgentID);
+
+    boost_tokenizer tokens(message, boost::char_separator<char>(",", "", boost::drop_empty_tokens));
+    for (const std::string& strCmd : tokens)
+    {
+        ECmdRet eRet = processCommand(chat.mFromID, strCmd, true);
+        if ( show_debug_output() &&
+             (!hide_unset_dupes() || (ECmdRet::SuccessUnset != eRet && ECmdRet::SuccessDuplicate != eRet)) )
+        {
+            cmdDbgOut.add(strCmd, eRet);
+        }
+    }
+
+    message = cmdDbgOut.get();
+    return true;
+}
+
+ECmdRet RlvHandler::processCommand(const LLUUID& idObj, const std::string& strCmd, bool fromObj)
+{
+    const RlvCommand rlvCmd(idObj, strCmd);
+    return processCommand(std::ref(rlvCmd), fromObj);
+}
+
+ECmdRet RlvHandler::processCommand(std::reference_wrapper<const RlvCommand> rlvCmd, bool fromObj)
+{
+    {
+        const RlvCommand& rlvCmdTmp = rlvCmd; // Reference to the temporary with limited variable scope since we don't want it to leak below
+
+        RLV_DEBUGS << "[" << rlvCmdTmp.getObjectID() << "]: " << rlvCmdTmp.asString() << RLV_ENDL;
+        if (!rlvCmdTmp.isValid())
+        {
+            RLV_DEBUGS << "\t-> invalid syntax" << RLV_ENDL;
+            return ECmdRet::FailedSyntax;
+        }
+        if (rlvCmdTmp.isBlocked())
+        {
+            RLV_DEBUGS << "\t-> blocked command" << RLV_ENDL;
+            return ECmdRet::FailedDisabled;
+        }
+    }
+
+    ECmdRet eRet = ECmdRet::Unknown;
+    switch (rlvCmd.get().getParamType())
+    {
+        case EParamType::Reply:
+            eRet = rlvCmd.get().processCommand();
+            break;
+        case EParamType::Unknown:
+        default:
+            eRet = ECmdRet::FailedParam;
+            break;
+    }
+    RLV_ASSERT(ECmdRet::Unknown != eRet);
+
+    RLV_DEBUGS << "\t--> command " << (isReturnCodeSuccess(eRet) ? "succeeded" : "failed") << RLV_ENDL;
+
+    return eRet;
+}
+
+// ============================================================================
+// Initialization helper functions
+//
+
+bool RlvHandler::canEnable()
+{
+    return LLStartUp::getStartupState() <= STATE_LOGIN_CLEANUP;
+}
+
+bool RlvHandler::setEnabled(bool enable)
+{
+    if (mIsEnabled == enable)
+        return enable;
+
+    if (enable && canEnable())
+    {
+        RLV_INFOS << "Enabling Restrained Love API support - " << Strings::getVersionAbout() << RLV_ENDL;
+        mIsEnabled = true;
+    }
+
+    return mIsEnabled;
+}
+
+// ============================================================================
+// Command handlers (RLV_TYPE_REPLY)
+//
+
+ECmdRet CommandHandlerBaseImpl<EParamType::Reply>::processCommand(const RlvCommand& rlvCmd, ReplyHandlerFunc* pHandler)
+{
+    // Sanity check - <param> should specify a - valid - reply channel
+    S32 nChannel;
+    if (!LLStringUtil::convertToS32(rlvCmd.getParam(), nChannel) || !Util::isValidReplyChannel(nChannel, rlvCmd.getObjectID() == gAgentID))
+        return ECmdRet::FailedParam;
+
+    std::string strReply;
+    ECmdRet eRet = (*pHandler)(rlvCmd, strReply);
+
+    // If we made it this far then:
+    //   - the command was handled successfully so we send off the response
+    //   - the command failed but we still send off an - empty - response to keep the issuing script from blocking
+    if (nChannel != 0)
+    {
+        Util::sendChatReply(nChannel, strReply);
+    }
+    RlvHandler::instance().mOnCommandOutput(rlvCmd, nChannel, strReply);
+
+    return eRet;
+}
+
+// Handles: @getcommand[:<behaviour>[;<type>[;<separator>]]]=<channel>
+template<> template<>
+ECmdRet ReplyHandler<EBehaviour::GetCommand>::onCommand(const RlvCommand& rlvCmd, std::string& strReply)
+{
+    std::vector<std::string> optionList;
+    Util::parseStringList(rlvCmd.getOption(), optionList);
+
+    // If a second parameter is present it'll specify the command type
+    EParamType eType = EParamType::Unknown;
+    if (optionList.size() >= 2)
+    {
+        if (optionList[1] == "any" || optionList[1].empty())
+            eType = EParamType::Unknown;
+        else if (optionList[1] == "add")
+            eType = EParamType::AddRem;
+        else if (optionList[1] == "force")
+            eType = EParamType::Force;
+        else if (optionList[1] == "reply")
+            eType = EParamType::Reply;
+        else
+            return ECmdRet::FailedOption;
+    }
+
+    std::list<std::string> cmdList;
+    if (BehaviourDictionary::instance().getCommands(!optionList.empty() ? optionList[0] : LLStringUtil::null, eType, cmdList))
+        strReply = boost::algorithm::join(cmdList, optionList.size() >= 3 ? optionList[2] : Constants::OptionSeparator);
+    return ECmdRet::Succeeded;
+}
+
+// Handles: @version=<chnannel> and @versionnew=<channel>
+template<> template<>
+ECmdRet VersionReplyHandler::onCommand(const RlvCommand& rlvCmd, std::string& strReply)
+{
+    strReply = Strings::getVersion(EBehaviour::Version == rlvCmd.getBehaviourType());
+    return ECmdRet::Succeeded;
+}
+
+// Handles: @versionnum[:impl]=<channel>
+template<> template<>
+ECmdRet ReplyHandler<EBehaviour::VersionNum>::onCommand(const RlvCommand& rlvCmd, std::string& strReply)
+{
+    if (!rlvCmd.hasOption())
+        strReply = Strings::getVersionNum();
+    else if ("impl" == rlvCmd.getOption())
+        strReply = Strings::getVersionImplNum();
+    else
+        return ECmdRet::FailedOption;
+    return ECmdRet::Succeeded;
+}
+
+// ============================================================================
diff --git a/indra/newview/rlvhandler.h b/indra/newview/rlvhandler.h
new file mode 100644
index 0000000000..38612485b1
--- /dev/null
+++ b/indra/newview/rlvhandler.h
@@ -0,0 +1,80 @@
+/**
+ * @file rlvhandler.h
+ * @author Kitty Barnett
+ * @brief Primary command process and orchestration class
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+#include "llchat.h"
+#include "llsingleton.h"
+
+#include "rlvhelper.h"
+
+class LLViewerObject;
+
+// ============================================================================
+// RlvHandler class
+//
+
+class RlvHandler : public LLSingleton<RlvHandler>
+{
+    template<Rlv::EParamType> friend struct Rlv::CommandHandlerBaseImpl;
+
+    LLSINGLETON_EMPTY_CTOR(RlvHandler);
+
+    /*
+     * Command processing
+     */
+public:
+    // Command processing helper functions
+    bool         handleSimulatorChat(std::string& message, const LLChat& chat, const LLViewerObject* chatObj);
+    Rlv::ECmdRet processCommand(const LLUUID& idObj, const std::string& stCmd, bool fromObj);
+protected:
+    Rlv::ECmdRet processCommand(std::reference_wrapper<const RlvCommand> rlvCmdRef, bool fromObj);
+
+    /*
+     * Helper functions
+     */
+public:
+    // Initialization (deliberately static so they can safely be called in tight loops)
+    static bool canEnable();
+    static bool isEnabled() { return mIsEnabled; }
+    static bool setEnabled(bool enable);
+
+    /*
+     * Event handling
+     */
+public:
+    // The command output signal is triggered whenever a command produces channel or debug output
+    using command_output_signal_t = boost::signals2::signal<void (const RlvCommand&, S32, const std::string&)>;
+    boost::signals2::connection setCommandOutputCallback(const command_output_signal_t::slot_type& cb) { return mOnCommandOutput.connect(cb); }
+
+protected:
+    command_output_signal_t mOnCommandOutput;
+private:
+    static bool mIsEnabled;
+};
+
+// ============================================================================
diff --git a/indra/newview/rlvhelper.cpp b/indra/newview/rlvhelper.cpp
new file mode 100644
index 0000000000..1dac297bf1
--- /dev/null
+++ b/indra/newview/rlvhelper.cpp
@@ -0,0 +1,389 @@
+/**
+ * @file rlvhelper.cpp
+ * @author Kitty Barnett
+ * @brief RLVa helper classes for internal use only
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "lltrans.h"
+#include "llviewercontrol.h"
+
+#include "rlvhelper.h"
+
+#include <boost/algorithm/string.hpp>
+
+using namespace Rlv;
+
+// ============================================================================
+// BehaviourDictionary
+//
+
+BehaviourDictionary::BehaviourDictionary()
+{
+    //
+    // Restrictions
+    //
+
+    //
+    // Reply-only
+    //
+    addEntry(new ReplyProcessor<EBehaviour::GetCommand>("getcommand"));
+    addEntry(new ReplyProcessor<EBehaviour::Version, VersionReplyHandler>("version"));
+    addEntry(new ReplyProcessor<EBehaviour::VersionNew, VersionReplyHandler>("versionnew"));
+    addEntry(new ReplyProcessor<EBehaviour::VersionNum>("versionnum"));
+
+    // Populate mString2InfoMap (the tuple <behaviour, type> should be unique)
+    for (const BehaviourInfo* bhvr_info_p : mBhvrInfoList)
+    {
+        mString2InfoMap.insert(std::make_pair(std::make_pair(bhvr_info_p->getBehaviour(), static_cast<EParamType>(bhvr_info_p->getParamTypeMask())), bhvr_info_p));
+    }
+
+    // Populate m_Bhvr2InfoMap (there can be multiple entries per ERlvBehaviour)
+    for (const BehaviourInfo* bhvr_info_p : mBhvrInfoList)
+    {
+        if ((bhvr_info_p->getParamTypeMask() & to_underlying(EParamType::AddRem)) && !bhvr_info_p->isSynonym())
+        {
+#ifdef RLV_DEBUG
+            for (const auto& itBhvr : boost::make_iterator_range(mBhvr2InfoMap.lower_bound(bhvr_info_p->getBehaviourType()), mBhvr2InfoMap.upper_bound(bhvr_info_p->getBehaviourType())))
+            {
+                RLV_ASSERT((itBhvr.first != bhvr_info_p->getBehaviourType()) || (itBhvr.second->getBehaviourFlags() != bhvr_info_p->getBehaviourFlags()));
+            }
+#endif // RLV_DEBUG
+            mBhvr2InfoMap.insert(std::pair(bhvr_info_p->getBehaviourType(), bhvr_info_p));
+        }
+    }
+}
+
+BehaviourDictionary::~BehaviourDictionary()
+{
+    for (const BehaviourInfo* bhvr_info_p : mBhvrInfoList)
+    {
+        delete bhvr_info_p;
+    }
+    mBhvrInfoList.clear();
+}
+
+void BehaviourDictionary::addEntry(const BehaviourInfo* entry_p)
+{
+    // Filter experimental commands (if disabled)
+    static LLCachedControl<bool> sEnableExperimental(gSavedSettings, Settings::EnableExperimentalCommands);
+    if (!entry_p || (!sEnableExperimental && entry_p->isExperimental()))
+    {
+        return;
+    }
+
+    // Sanity check for duplicate entries
+#if LL_RELEASE_WITH_DEBUG_INFO || LL_DEBUG
+    std::for_each(mBhvrInfoList.begin(), mBhvrInfoList.end(),
+        [&entry_p](const BehaviourInfo* bhvr_info_p) {
+            RLV_ASSERT_DBG((bhvr_info_p->getBehaviour() != entry_p->getBehaviour()) || ((bhvr_info_p->getParamTypeMask() & entry_p->getParamTypeMask()) == 0));
+        });
+#endif // LL_RELEASE_WITH_DEBUG_INFO || LL_DEBUG
+
+    mBhvrInfoList.push_back(entry_p);
+}
+
+const BehaviourInfo* BehaviourDictionary::getBehaviourInfo(EBehaviour eBhvr, EParamType eParamType) const
+{
+    const BehaviourInfo* bhvr_info_p = nullptr;
+    for (auto itBhvrLower = mBhvr2InfoMap.lower_bound(eBhvr), itBhvrUpper = mBhvr2InfoMap.upper_bound(eBhvr);
+        std::find_if(itBhvrLower, itBhvrUpper, [eParamType](const auto& bhvrEntry) { return bhvrEntry.second->getParamTypeMask() == to_underlying(eParamType); }) != itBhvrUpper;
+        ++itBhvrLower)
+    {
+        if (bhvr_info_p)
+            return nullptr;
+        bhvr_info_p = itBhvrLower->second;
+    }
+    return bhvr_info_p;
+}
+
+const BehaviourInfo* BehaviourDictionary::getBehaviourInfo(const std::string& strBhvr, EParamType eParamType, bool* is_strict_p) const
+{
+    size_t idxBhvrLastPart = strBhvr.find_last_of('_');
+    std::string strBhvrLastPart((std::string::npos != idxBhvrLastPart) && (idxBhvrLastPart < strBhvr.size()) ? strBhvr.substr(idxBhvrLastPart + 1) : LLStringUtil::null);
+
+    bool isStrict = (strBhvrLastPart.compare("sec") == 0);
+    if (is_strict_p)
+        *is_strict_p = isStrict;
+
+    auto itBhvr = mString2InfoMap.find(std::make_pair((!isStrict) ? strBhvr : strBhvr.substr(0, strBhvr.size() - 4), (has_flag(eParamType, EParamType::AddRem)) ? EParamType::AddRem : eParamType));
+    if ((mString2InfoMap.end() == itBhvr) && (!isStrict) && (!strBhvrLastPart.empty()) && (EParamType::Force == eParamType))
+    {
+        // No match found but it could still be a local scope modifier
+        auto itBhvrMod = mString2InfoMap.find(std::make_pair(strBhvr.substr(0, idxBhvrLastPart), EParamType::AddRem));
+    }
+
+    return ((itBhvr != mString2InfoMap.end()) && ((!isStrict) || (itBhvr->second->hasStrict()))) ? itBhvr->second : nullptr;
+}
+
+EBehaviour BehaviourDictionary::getBehaviourFromString(const std::string& strBhvr, EParamType eParamType, bool* pisStrict) const
+{
+    const BehaviourInfo* bhvr_info_p = getBehaviourInfo(strBhvr, eParamType, pisStrict);
+    // Filter out locally scoped modifier commands since they don't actually have a unique behaviour value of their own
+    return bhvr_info_p->getBehaviourType();
+}
+
+bool BehaviourDictionary::getCommands(const std::string& strMatch, EParamType eParamType, std::list<std::string>& cmdList) const
+{
+    cmdList.clear();
+    for (const BehaviourInfo* bhvr_info_p : mBhvrInfoList)
+    {
+        if ((bhvr_info_p->getParamTypeMask() & to_underlying(eParamType)) || (EParamType::Unknown == eParamType))
+        {
+            std::string strCmd = bhvr_info_p->getBehaviour();
+            if ((std::string::npos != strCmd.find(strMatch)) || (strMatch.empty()))
+                cmdList.push_back(strCmd);
+            if ((bhvr_info_p->hasStrict()) && ((std::string::npos != strCmd.append("_sec").find(strMatch)) || (strMatch.empty())))
+                cmdList.push_back(strCmd);
+        }
+    }
+    return !cmdList.empty();
+}
+
+bool BehaviourDictionary::getHasStrict(EBehaviour eBhvr) const
+{
+    for (const auto& itBhvr : boost::make_iterator_range(mBhvr2InfoMap.lower_bound(eBhvr), mBhvr2InfoMap.upper_bound(eBhvr)))
+    {
+        // Only restrictions can be strict
+        if (to_underlying(EParamType::AddRem) != itBhvr.second->getParamTypeMask())
+            continue;
+        return itBhvr.second->hasStrict();
+    }
+    RLV_ASSERT(false);
+    return false;
+}
+
+void BehaviourDictionary::toggleBehaviourFlag(const std::string& strBhvr, EParamType eParamType, BehaviourInfo::EBehaviourFlags eBhvrFlag, bool fEnable)
+{
+    auto itBhvr = mString2InfoMap.find(std::make_pair(strBhvr, (has_flag(eParamType, EParamType::AddRem)) ? EParamType::AddRem : eParamType));
+    if (mString2InfoMap.end() != itBhvr)
+    {
+        const_cast<BehaviourInfo*>(itBhvr->second)->toggleBehaviourFlag(eBhvrFlag, fEnable);
+    }
+}
+
+// ============================================================================
+// RlvCommmand
+//
+
+RlvCommand::RlvCommand(const LLUUID& idObj, const std::string& strCmd)
+    : mObjId(idObj)
+{
+    if (parseCommand(strCmd, mBehaviour, mOption, mParam))
+    {
+         if ("n" == mParam || "add" == mParam)
+             mParamType = EParamType::Add;
+         else if ("y" == mParam || "rem" == mParam)
+             mParamType = EParamType::Remove;
+         else if ("clear" == mBehaviour)                                     // clear is the odd one out so just make it its own type
+             mParamType = EParamType::Clear;
+         else if ("force" == mParam)
+             mParamType = EParamType::Force;
+         else if (S32 nTemp; LLStringUtil::convertToS32(mParam, nTemp))  // Assume it's a reply command if we can convert <param> to an S32
+            mParamType = EParamType::Reply;
+    }
+
+    mIsValid = mParamType != EParamType::Unknown;
+    if (!mIsValid)
+    {
+        mOption.clear();
+        mParam.clear();
+        return;
+    }
+
+    mBhvrInfo = BehaviourDictionary::instance().getBehaviourInfo(mBehaviour, mParamType, &mIsStrict);
+}
+
+RlvCommand::RlvCommand(const RlvCommand& rlvCmd, EParamType eParamType)
+    : mIsValid(rlvCmd.mIsValid), mObjId(rlvCmd.mObjId), mBehaviour(rlvCmd.mBehaviour), mBhvrInfo(rlvCmd.mBhvrInfo)
+    , mParamType( (EParamType::Unknown == eParamType) ? rlvCmd.mParamType : eParamType)
+    , mIsStrict(rlvCmd.mIsStrict), mOption(rlvCmd.mOption), mParam(rlvCmd.mParam), mIsRefCounted(rlvCmd.mIsRefCounted)
+{
+}
+
+bool RlvCommand::parseCommand(const std::string& strCmd, std::string& strBhvr, std::string& strOption, std::string& strParam)
+{
+    // Format: <behaviour>[:<option>]=<param>
+    const size_t idxOption = strCmd.find(':');
+    const size_t idxParam  = strCmd.find('=');
+
+    // If <behaviour> is missing it's always an improperly formatted command
+    // If there's an option, but it comes after <param> it's also invalid
+    if ( (idxOption == 0 || idxParam == 0) ||
+         (idxOption != std::string::npos && idxOption >= idxParam) )
+    {
+        return false;
+    }
+
+    strBhvr = strCmd.substr(0, std::string::npos != idxOption ? idxOption : idxParam);
+    strOption = strParam = "";
+
+    // If <param> is missing it's an improperly formatted command
+    if (idxParam == std::string::npos || idxParam + 1 == strCmd.length())
+    {
+        // Unless "<behaviour> == "clear" AND (idxOption == 0)"
+        // OR <behaviour> == "clear" AND (idxParam != 0)
+        if (strBhvr == "clear" && (!idxOption || idxParam))
+            return true;
+        return false;
+    }
+
+    if (idxOption != std::string::npos && idxOption + 1 != idxParam)
+        strOption = strCmd.substr(idxOption + 1, idxParam - idxOption - 1);
+    strParam = strCmd.substr(idxParam + 1);
+
+    return true;
+}
+
+std::string RlvCommand::asString() const
+{
+    // NOTE: @clear=<param> should be represented as clear:<param>
+    return mParamType != EParamType::Clear
+        ? getBehaviour() + (!mOption.empty() ? ":" + mOption : "")
+        : getBehaviour() + (!mParam.empty() ? ":" + mParam : "");
+}
+
+// =========================================================================
+// Various helper classes/timers/functors
+//
+
+namespace Rlv
+{
+    // ===========================================================================
+    // CommandDbgOut
+    //
+
+    void CommandDbgOut::add(std::string strCmd, ECmdRet eRet)
+    {
+        const std::string strSuffix = getReturnCodeString(eRet);
+        if (!strSuffix.empty())
+            strCmd.append(llformat(" (%s)", strSuffix.c_str()));
+        else if (mForConsole)
+            return; // Only show console feedback on successful commands when there's an informational notice
+
+        std::string& strResult = mCommandResults[isReturnCodeSuccess(eRet) ? ECmdRet::Succeeded : (ECmdRet::Retained == eRet ? ECmdRet::Retained : ECmdRet::Failed)];
+        if (!strResult.empty())
+            strResult.append(", ");
+        strResult.append(strCmd);
+    }
+
+    std::string CommandDbgOut::get() const {
+        std::ostringstream result;
+
+        if (1 == mCommandResults.size() && !mForConsole)
+        {
+            auto it = mCommandResults.begin();
+            result << " " << getDebugVerbFromReturnCode(it->first) << ": @" << it->second;
+        }
+        else if (!mCommandResults.empty())
+        {
+            auto appendResult = [&](ECmdRet eRet, const std::string& name)
+                {
+                    auto it = mCommandResults.find(eRet);
+                    if (it == mCommandResults.end()) return;
+                    if (!mForConsole) result << "\n    - ";
+                    result << LLTrans::getString(name) << ": @" << it->second;
+                };
+            if (!mForConsole)
+                result << ": @" << mOrigCmd;
+            appendResult(ECmdRet::Succeeded, !mForConsole ? "RlvDebugExecuted" : "RlvConsoleExecuted");
+            appendResult(ECmdRet::Failed, !mForConsole ? "RlvDebugFailed" : "RlvConsoleFailed");
+            appendResult(ECmdRet::Retained, !mForConsole ? "RlvDebugRetained" : "RlvConsoleRetained");
+        }
+
+        return result.str();
+    }
+
+    std::string CommandDbgOut::getDebugVerbFromReturnCode(ECmdRet eRet)
+    {
+        switch (eRet)
+        {
+            case ECmdRet::Succeeded:
+                return LLTrans::getString("RlvDebugExecuted");
+            case ECmdRet::Failed:
+                return LLTrans::getString("RlvDebugFailed");
+            case ECmdRet::Retained:
+                return LLTrans::getString("RlvDebugRetained");
+            default:
+                RLV_ASSERT(false);
+                return LLStringUtil::null;
+        }
+    }
+
+    std::string CommandDbgOut::getReturnCodeString(ECmdRet eRet)
+    {
+        switch (eRet)
+        {
+            case ECmdRet::SuccessUnset:
+                return LLTrans::getString("RlvReturnCodeUnset");
+            case ECmdRet::SuccessDuplicate:
+                return LLTrans::getString("RlvReturnCodeDuplicate");
+            case ECmdRet::SuccessDelayed:
+                return LLTrans::getString("RlvReturnCodeDelayed");
+            case ECmdRet::SuccessDeprecated:
+                return LLTrans::getString("RlvReturnCodeDeprecated");
+            case ECmdRet::FailedSyntax:
+                return LLTrans::getString("RlvReturnCodeSyntax");
+            case ECmdRet::FailedOption:
+                return LLTrans::getString("RlvReturnCodeOption");
+            case ECmdRet::FailedParam:
+                return LLTrans::getString("RlvReturnCodeParam");
+            case ECmdRet::FailedLock:
+                return LLTrans::getString("RlvReturnCodeLock");
+            case ECmdRet::FailedDisabled:
+                return LLTrans::getString("RlvReturnCodeDisabled");
+            case ECmdRet::FailedUnknown:
+                return LLTrans::getString("RlvReturnCodeUnknown");
+            case ECmdRet::FailedNoSharedRoot:
+                return LLTrans::getString("RlvReturnCodeNoSharedRoot");
+            case ECmdRet::FailedDeprecated:
+                return LLTrans::getString("RlvReturnCodeDeprecatedAndDisabled");
+            case ECmdRet::FailedNoBehaviour:
+                return LLTrans::getString("RlvReturnCodeNoBehaviour");
+            case ECmdRet::FailedUnheldBehaviour:
+                return LLTrans::getString("RlvReturnCodeUnheldBehaviour");
+            case ECmdRet::FailedBlocked:
+                return LLTrans::getString("RlvReturnCodeBlocked");
+            case ECmdRet::FailedThrottled:
+                return LLTrans::getString("RlvReturnCodeThrottled");
+            case ECmdRet::FailedNoProcessor:
+                return LLTrans::getString("RlvReturnCodeNoProcessor");
+            // The following are identified by the chat verb
+            case ECmdRet::Retained:
+            case ECmdRet::Succeeded:
+            case ECmdRet::Failed:
+                return LLStringUtil::null;
+            // The following shouldn't occur
+            case ECmdRet::Unknown:
+            default:
+                RLV_ASSERT(false);
+                return LLStringUtil::null;
+        }
+    }
+
+    // ===========================================================================
+}
+
+// ============================================================================
diff --git a/indra/newview/rlvhelper.h b/indra/newview/rlvhelper.h
new file mode 100644
index 0000000000..f241332594
--- /dev/null
+++ b/indra/newview/rlvhelper.h
@@ -0,0 +1,299 @@
+/**
+ * @file rlvhelper.h
+ * @author Kitty Barnett
+ * @brief RLVa helper classes for internal use only
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#pragma once
+
+#include "rlvdefines.h"
+
+// ============================================================================
+// Forward declarations
+//
+
+class RlvCommand;
+
+// ============================================================================
+
+namespace Rlv
+{
+    // ============================================================================
+    // BehaviourInfo class - Generic behaviour descriptor (used by restrictions, reply and force commands)
+    //
+
+    class BehaviourInfo
+    {
+    public:
+        enum EBehaviourFlags : uint32_t
+        {
+            // General behaviour flags
+            Strict = 0x0001,				// Behaviour has a "_sec" version
+            Synonym = 0x0002,				// Behaviour is a synonym of another
+            Extended = 0x0004,				// Behaviour is part of the RLVa extended command set
+            Experimental = 0x0008,			// Behaviour is part of the RLVa experimental command set
+            Blocked = 0x0010,				// Behaviour is blocked
+            Deprecated = 0x0020,			// Behaviour is deprecated
+            MaskGeneral = 0x0FFF,
+
+            // Force-wear specific flags
+            ForceWear_WearReplace = 0x0001 << 16,
+            ForceWear_WearAdd = 0x0002 << 16,
+            ForceWear_WearRemove = 0x0004 << 16,
+            ForceWear_Node = 0x0010 << 16,
+            ForceWear_Subtree = 0x0020 << 16,
+            ForceWear_ContextNone = 0x0100 << 16,
+            ForceWear_ContextObject = 0x0200 << 16,
+            MaskForceWear = 0xFFFFu << 16
+        };
+
+        BehaviourInfo(const std::string& strBhvr, EBehaviour eBhvr, EParamType maskParamType, std::underlying_type_t<EBehaviourFlags> nBhvrFlags = 0)
+            : mBhvr(strBhvr), mBhvrType(eBhvr), mBhvrFlags(nBhvrFlags), mMaskParamType(to_underlying(maskParamType)) {}
+        virtual ~BehaviourInfo() {}
+
+        const std::string&    getBehaviour() const { return mBhvr; }
+        EBehaviour            getBehaviourType() const { return mBhvrType; }
+        std::underlying_type_t<EBehaviourFlags> getBehaviourFlags() const { return mBhvrFlags; }
+        std::underlying_type_t<EParamType> getParamTypeMask() const { return mMaskParamType; }
+        bool                  hasStrict() const { return mBhvrFlags & Strict; }
+        bool                  isBlocked() const { return mBhvrFlags & Blocked; }
+        bool                  isExperimental() const { return mBhvrFlags & Experimental; }
+        bool                  isExtended() const { return mBhvrFlags & Extended; }
+        bool                  isSynonym() const { return mBhvrFlags & Synonym; }
+        void                  toggleBehaviourFlag(EBehaviourFlags eBhvrFlag, bool fEnable);
+
+        virtual ECmdRet  processCommand(const RlvCommand& rlvCmd) const { return ECmdRet::FailedNoProcessor; }
+
+    protected:
+        std::string mBhvr;
+        EBehaviour mBhvrType;
+        std::underlying_type_t<EBehaviourFlags> mBhvrFlags;
+        std::underlying_type_t<EParamType> mMaskParamType;
+    };
+
+    inline void BehaviourInfo::toggleBehaviourFlag(EBehaviourFlags eBhvrFlag, bool fEnable)
+    {
+        if (fEnable)
+            mBhvrFlags |= eBhvrFlag;
+        else
+            mBhvrFlags &= ~eBhvrFlag;
+    }
+
+    // ============================================================================
+    // BehaviourDictionary and related classes
+    //
+
+    class BehaviourDictionary : public LLSingleton<BehaviourDictionary>
+    {
+        LLSINGLETON(BehaviourDictionary);
+    protected:
+        ~BehaviourDictionary() override;
+    public:
+        void addEntry(const BehaviourInfo* entry_p);
+
+        /*
+         * General helper functions
+         */
+    public:
+        EBehaviour           getBehaviourFromString(const std::string& strBhvr, EParamType eParamType, bool* is_strict_p = nullptr) const;
+        const BehaviourInfo* getBehaviourInfo(EBehaviour eBhvr, EParamType eParamType) const;
+        const BehaviourInfo* getBehaviourInfo(const std::string& strBhvr, EParamType eParamType, bool* is_strict_p = nullptr) const;
+        bool                 getCommands(const std::string& strMatch, EParamType eParamType, std::list<std::string>& cmdList) const;
+        bool                 getHasStrict(EBehaviour eBhvr) const;
+        void                 toggleBehaviourFlag(const std::string& strBhvr, EParamType eParamType, BehaviourInfo::EBehaviourFlags eBvhrFlag, bool fEnable);
+
+        /*
+         * Member variables
+         */
+    protected:
+        std::list<const BehaviourInfo*> mBhvrInfoList;
+        std::map<std::pair<std::string, EParamType>, const BehaviourInfo*> mString2InfoMap;
+        std::multimap<EBehaviour, const BehaviourInfo*> mBhvr2InfoMap;
+    };
+
+    // ============================================================================
+    // CommandHandler and related classes
+    //
+
+    typedef ECmdRet(BhvrHandlerFunc)(const RlvCommand&, bool&);
+    typedef void(BhvrToggleHandlerFunc)(EBehaviour, bool);
+    typedef ECmdRet(ForceHandlerFunc)(const RlvCommand&);
+    typedef ECmdRet(ReplyHandlerFunc)(const RlvCommand&, std::string&);
+
+    //
+    // CommandHandlerBaseImpl - Base implementation for each command type (the old process(AddRem|Force|Reply)Command functions)
+    //
+    template<EParamType paramType> struct CommandHandlerBaseImpl;
+    template<> struct CommandHandlerBaseImpl<EParamType::AddRem> { static ECmdRet processCommand(const RlvCommand&, BhvrHandlerFunc*, BhvrToggleHandlerFunc* = nullptr); };
+    template<> struct CommandHandlerBaseImpl<EParamType::Force>  { static ECmdRet processCommand(const RlvCommand&, ForceHandlerFunc*); };
+    template<> struct CommandHandlerBaseImpl<EParamType::Reply>  { static ECmdRet processCommand(const RlvCommand&, ReplyHandlerFunc*); };
+
+    //
+    // CommandHandler - The actual command handler (Note that a handler is more general than a processor; a handler can - for instance - be used by multiple processors)
+    //
+    #if LL_WINDOWS
+        #define RLV_TEMPL_FIX(x) template<x>
+    #else
+        #define RLV_TEMPL_FIX(x) template<typename Placeholder = int>
+    #endif // LL_WINDOWS
+
+
+    template <EParamType templParamType, EBehaviour templBhvr>
+    struct CommandHandler
+    {
+        RLV_TEMPL_FIX(typename = typename std::enable_if<templParamType == EParamType::AddRem>::type) static ECmdRet onCommand(const RlvCommand&, bool&);
+        RLV_TEMPL_FIX(typename = typename std::enable_if<templParamType == EParamType::AddRem>::type) static void onCommandToggle(EBehaviour, bool);
+        RLV_TEMPL_FIX(typename = typename std::enable_if<templParamType == EParamType::Force>::type)  static ECmdRet onCommand(const RlvCommand&);
+        RLV_TEMPL_FIX(typename = typename std::enable_if<templParamType == EParamType::Reply>::type)  static ECmdRet onCommand(const RlvCommand&, std::string&);
+    };
+
+    // Aliases to improve readability in definitions
+    template<EBehaviour templBhvr> using BehaviourHandler = CommandHandler<EParamType::AddRem, templBhvr>;
+    template<EBehaviour templBhvr> using BehaviourToggleHandler = BehaviourHandler<templBhvr>;
+    template<EBehaviour templBhvr> using ForceHandler = CommandHandler<EParamType::Force, templBhvr>;
+    template<EBehaviour templBhvr> using ReplyHandler = CommandHandler<EParamType::Reply, templBhvr>;
+
+    // List of shared handlers
+    using VersionReplyHandler = ReplyHandler<EBehaviour::Version>;				// Shared between @version and @versionnew
+
+    //
+    // CommandProcessor - Templated glue class that brings BehaviourInfo, CommandHandlerBaseImpl and CommandHandler together
+    //
+    template <EParamType templParamType, EBehaviour templBhvr, typename handlerImpl = CommandHandler<templParamType, templBhvr>, typename baseImpl = CommandHandlerBaseImpl<templParamType>>
+    class CommandProcessor : public BehaviourInfo
+    {
+    public:
+        // Default constructor used by behaviour specializations
+        RLV_TEMPL_FIX(typename = typename std::enable_if<templBhvr != EBehaviour::Unknown>::type)
+        CommandProcessor(const std::string& strBhvr, U32 nBhvrFlags = 0) : BehaviourInfo(strBhvr, templBhvr, templParamType, nBhvrFlags) {}
+
+        // Constructor used when we don't want to specialize on behaviour (see BehaviourGenericProcessor)
+        RLV_TEMPL_FIX(typename = typename std::enable_if<templBhvr == EBehaviour::Unknown>::type)
+        CommandProcessor(const std::string& strBhvr, EBehaviour eBhvr, U32 nBhvrFlags = 0) : BehaviourInfo(strBhvr, eBhvr, templParamType, nBhvrFlags) {}
+
+        ECmdRet processCommand(const RlvCommand& rlvCmd) const override { return baseImpl::processCommand(rlvCmd, &handlerImpl::onCommand); }
+    };
+
+    // Aliases to improve readability in definitions
+    template<EBehaviour templBhvr, typename handlerImpl = CommandHandler<EParamType::AddRem, templBhvr>> using BehaviourProcessor = CommandProcessor<EParamType::AddRem, templBhvr, handlerImpl>;
+    template<EBehaviour templBhvr, typename handlerImpl = CommandHandler<EParamType::Force, templBhvr>> using ForceProcessor = CommandProcessor<EParamType::Force, templBhvr, handlerImpl>;
+    template<EBehaviour templBhvr, typename handlerImpl = CommandHandler<EParamType::Reply, templBhvr>> using ReplyProcessor = CommandProcessor<EParamType::Reply, templBhvr, handlerImpl>;
+
+    // Provides pre-defined generic implementations of basic behaviours (template voodoo - see original commit for something that still made sense)
+    template<EBehaviourOptionType templOptionType> struct BehaviourGenericHandler { static ECmdRet onCommand(const RlvCommand& rlvCmd, bool& fRefCount); };
+    template<EBehaviourOptionType templOptionType> using BehaviourGenericProcessor = BehaviourProcessor<EBehaviour::Unknown, BehaviourGenericHandler<templOptionType>>;
+    template<EBehaviourOptionType templOptionType> struct ForceGenericHandler { static ECmdRet onCommand(const RlvCommand& rlvCmd); };
+    template<EBehaviourOptionType templOptionType> using ForceGenericProcessor = ForceProcessor<EBehaviour::Unknown, ForceGenericHandler<templOptionType>>;
+
+    // ============================================================================
+    // BehaviourProcessor and related classes - Handles add/rem comamnds aka "restrictions)
+    //
+
+    template <EBehaviour eBhvr, typename handlerImpl = BehaviourHandler<eBhvr>, typename toggleHandlerImpl = BehaviourToggleHandler<eBhvr>>
+    class BehaviourToggleProcessor : public BehaviourInfo
+    {
+    public:
+        BehaviourToggleProcessor(const std::string& strBhvr, U32 nBhvrFlags = 0) : BehaviourInfo(strBhvr, eBhvr, EParamType::AddRem, nBhvrFlags) {}
+        ECmdRet processCommand(const RlvCommand& rlvCmd) const override { return CommandHandlerBaseImpl<EParamType::AddRem>::processCommand(rlvCmd, &handlerImpl::onCommand, &toggleHandlerImpl::onCommandToggle); }
+    };
+    template <EBehaviour eBhvr, EBehaviourOptionType optionType, typename toggleHandlerImpl = BehaviourToggleHandler<eBhvr>> using RlvBehaviourGenericToggleProcessor = BehaviourToggleProcessor<eBhvr, BehaviourGenericHandler<optionType>, toggleHandlerImpl>;
+
+    // ============================================================================
+    // Various helper classes/timers/functors
+    //
+
+    struct CommandDbgOut
+    {
+        CommandDbgOut(const std::string& orig_cmd, bool for_console) : mOrigCmd(orig_cmd), mForConsole(for_console) {}
+        void add(std::string strCmd, ECmdRet eRet);
+        std::string get() const;
+        static std::string getDebugVerbFromReturnCode(ECmdRet eRet);
+        static std::string getReturnCodeString(ECmdRet eRet);
+    private:
+        std::string mOrigCmd;
+        std::map<ECmdRet, std::string> mCommandResults;
+        bool mForConsole = false;
+    };
+}
+
+// ============================================================================
+// RlvCommand
+//
+
+class RlvCommand
+{
+public:
+    explicit RlvCommand(const LLUUID& idObj, const std::string& strCmd);
+    RlvCommand(const RlvCommand& rlvCmd, Rlv::EParamType eParamType = Rlv::EParamType::Unknown);
+
+    /*
+     * Member functions
+     */
+public:
+    std::string        asString() const;
+    const std::string& getBehaviour() const { return mBehaviour; }
+    const Rlv::BehaviourInfo* getBehaviourInfo() const { return mBhvrInfo; }
+    Rlv::EBehaviour    getBehaviourType() const { return (mBhvrInfo) ? mBhvrInfo->getBehaviourType() : Rlv::EBehaviour::Unknown; }
+    U32                getBehaviourFlags() const { return (mBhvrInfo) ? mBhvrInfo->getBehaviourFlags() : 0; }
+    const LLUUID&      getObjectID() const { return mObjId; }
+    const std::string& getOption() const { return mOption; }
+    const std::string& getParam() const { return mParam; }
+    Rlv::EParamType    getParamType() const { return mParamType; }
+    bool               hasOption() const { return !mOption.empty(); }
+    bool               isBlocked() const { return (mBhvrInfo) ? mBhvrInfo->isBlocked() : false; }
+    bool               isRefCounted() const { return mIsRefCounted; }
+    bool               isStrict() const { return mIsStrict; }
+    bool               isValid() const { return mIsValid; }
+    Rlv::ECmdRet       processCommand() const { return (mBhvrInfo) ? mBhvrInfo->processCommand(*this) : Rlv::ECmdRet::FailedNoProcessor; }
+
+protected:
+    static bool parseCommand(const std::string& strCommand, std::string& strBehaviour, std::string& strOption, std::string& strParam);
+    bool               markRefCounted() const { return mIsRefCounted = true; }
+
+    /*
+     * Operators
+     */
+public:
+    bool operator ==(const RlvCommand&) const;
+
+    /*
+     * Member variables
+     */
+protected:
+    bool                    mIsValid = false;
+    LLUUID                  mObjId;
+    std::string             mBehaviour;
+    const Rlv::BehaviourInfo* mBhvrInfo = nullptr;
+    Rlv::EParamType         mParamType = Rlv::EParamType::Unknown;
+    bool                    mIsStrict = false;
+    std::string             mOption;
+    std::string             mParam;
+    mutable bool            mIsRefCounted = false;
+
+    friend class RlvHandler;
+    friend class RlvObject;
+    template<Rlv::EParamType> friend struct Rlv::CommandHandlerBaseImpl;
+};
+
+// ============================================================================
diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 4a1132fe7e..6068a916ed 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -1,8 +1,26 @@
 local leap = require 'leap'
 local mapargs = require 'mapargs'
+local result_view = require 'result_view'
+
+local function result(keys)
+    local result_table = {
+        result=result_view(keys.result),
+        -- call result_table:close() to release result sets before garbage
+        -- collection or script completion
+        close = function(self)
+            result_view.close(keys.result[1])
+        end
+    }
+    -- When the result_table is destroyed, close its result_views.
+    return LL.setdtor('LLAgent result', result_table, result_table.close)
+end
 
 local LLAgent = {}
 
+function LLAgent.getID()
+    return leap.request('LLAgent', {op = 'getID'}).id
+end
+
 function LLAgent.getRegionPosition()
     return leap.request('LLAgent', {op = 'getPosition'}).region
 end
@@ -95,6 +113,33 @@ function LLAgent.requestStand()
     leap.send('LLAgent', {op = 'requestStand'})
 end
 
+-- Get the nearby avatars in a range of provided "dist",
+-- if "dist" is not specified, "RenderFarClip" setting is used
+-- reply will contain "result" table with following fields:
+-- "id", "global_pos", "region_pos",  "name", "region_id"
+function LLAgent.getNearbyAvatarsList(...)
+    local args = mapargs('dist', ...)
+    args.op = 'getNearbyAvatarsList'
+    return result(leap.request('LLAgent', args))
+end
+
+-- reply will contain "result" table with following fields:
+-- "id", "global_pos", "region_pos", "region_id"
+function LLAgent.getNearbyObjectsList(...)
+    local args = mapargs('dist', ...)
+    args.op = 'getNearbyObjectsList'
+    return result(leap.request('LLAgent', args))
+end
+
+-- Get screen position of your own avatar or any other (if "avatar_id" is specified)
+-- reply contains "x", "y" coordinates and "onscreen" flag to indicate if it's actually in within the current window
+-- avatar render position is used as the point
+function LLAgent.getAgentScreenPos(...)
+    local args = mapargs('avatar_id', ...)
+    args.op = 'getAgentScreenPos'
+    return leap.request('LLAgent', args)
+end
+
 -- ***************************************************************************
 --  Autopilot
 -- ***************************************************************************
diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index cf2695917e..34f3fb75eb 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -222,8 +222,10 @@ function UI.hideFloater(floater_name)
     leap.send("LLFloaterReg", {op = "hideInstance", name = floater_name})
 end
 
-function UI.toggleFloater(floater_name)
-    leap.send("LLFloaterReg", {op = "toggleInstance", name = floater_name})
+function UI.toggleFloater(...)
+    local args = mapargs('name,key', ...)
+    args.op = 'toggleInstance'
+    leap.send("LLFloaterReg", args)
 end
 
 function UI.isFloaterVisible(floater_name)
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
index 0f269b54e6..fa00b048b2 100644
--- a/indra/newview/scripts/lua/test_LLChatListener.lua
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -1,5 +1,6 @@
-local LLListener = require 'LLListener'
+local LLAgent = require 'LLAgent'
 local LLChat = require 'LLChat'
+local LLListener = require 'LLListener'
 local UI = require 'UI'
 
 -- Chat listener script allows to use the following commands in Nearby chat:
@@ -23,9 +24,13 @@ function openOrEcho(message)
 end
 
 local listener = LLListener(LLChat.nearbyChatPump)
+local agent_id = LLAgent.getID()
 
 function listener:handleMessages(event_data)
-    if string.find(event_data.message, '[LUA]') then
+    -- ignore messages and commands from other avatars
+    if event_data.from_id ~= agent_id then
+      return true
+    elseif string.find(event_data.message, '[LUA]') then
       return true
     elseif event_data.message == 'stop' then
       LLChat.sendNearby('Closing echo script.')
diff --git a/indra/newview/scripts/lua/test_animation.lua b/indra/newview/scripts/lua/test_animation.lua
index 37e7254a6c..ae5eabe148 100644
--- a/indra/newview/scripts/lua/test_animation.lua
+++ b/indra/newview/scripts/lua/test_animation.lua
@@ -7,8 +7,8 @@ animations_id = LLInventory.getBasicFolderID('animatn')
 anims = LLInventory.collectDescendentsIf{folder_id=animations_id, type="animatn"}.items
 
 local anim_ids = {}
-for key in pairs(anims) do
-    table.insert(anim_ids, key)
+for _, key in pairs(anims) do
+    table.insert(anim_ids, {id = key.id, name = key.name})
 end
 
 if #anim_ids == 0 then
@@ -16,17 +16,17 @@ if #anim_ids == 0 then
 else
     -- Start playing a random animation
     math.randomseed(os.time())
-    local random_id = anim_ids[math.random(#anim_ids)]
-    local anim_info = LLAgent.getAnimationInfo(random_id)
+    local random_anim = anim_ids[math.random(#anim_ids)]
+    local anim_info = LLAgent.getAnimationInfo(random_anim.id)
 
-    print("Starting animation locally: " .. anims[random_id].name)
-    print("Loop: " .. anim_info.is_loop .. " Joints: " .. anim_info.num_joints .. " Duration " .. tonumber(string.format("%.2f", anim_info.duration)))
-    LLAgent.playAnimation{item_id=random_id}
+    print("Starting animation locally: " .. random_anim.name)
+    print("Loop: " .. tostring(anim_info.is_loop) .. " Joints: " .. anim_info.num_joints .. " Duration " .. tonumber(string.format("%.2f", anim_info.duration)))
+    LLAgent.playAnimation{item_id=random_anim.id}
 
     -- Stop animation after 3 sec if it's looped or longer than 3 sec
-    if anim_info.is_loop == 1 or anim_info.duration > 3 then
+    if anim_info.is_loop or anim_info.duration > 3 then
         LL.sleep(3)
         print("Stop animation.")
-        LLAgent.stopAnimation(random_id)
+        LLAgent.stopAnimation(random_anim.id)
     end
 end
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index 2158134511..23310c6176 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -14,7 +14,7 @@ function flt:handleEvents(event_data)
 end
 
 function flt:commit_disable_ctrl(event_data)
-    self:post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
+    self:post({action="set_enabled", ctrl_name="open_btn", value = not event_data.value})
 end
 
 function flt:commit_title_cmb(event_data)
diff --git a/indra/newview/scripts/lua/test_nearby_avatars.lua b/indra/newview/scripts/lua/test_nearby_avatars.lua
new file mode 100644
index 0000000000..c7fa686076
--- /dev/null
+++ b/indra/newview/scripts/lua/test_nearby_avatars.lua
@@ -0,0 +1,25 @@
+inspect = require 'inspect'
+LLAgent = require 'LLAgent'
+
+-- Get the list of nearby avatars and print the info
+local nearby_avatars = LLAgent.getNearbyAvatarsList()
+if nearby_avatars.result.length == 0 then
+    print("No avatars nearby")
+else
+    print("Nearby avatars:")
+    for _, av in pairs(nearby_avatars.result) do
+        print(av.name ..' ID: ' .. av.id ..' Global pos:' .. inspect(av.global_pos))
+    end
+end
+
+-- Get the list of nearby objects in 3m range and print the info
+local nearby_objects = LLAgent.getNearbyObjectsList(3)
+if nearby_objects.result.length == 0 then
+    print("No objects nearby")
+else
+    print("Nearby objects:")
+    local pos={}
+    for _, obj in pairs(nearby_objects.result) do
+      print('ID: ' .. obj.id ..' Global pos:' .. inspect(obj.global_pos))
+    end
+end
diff --git a/indra/newview/scripts/lua/test_screen_position.lua b/indra/newview/scripts/lua/test_screen_position.lua
new file mode 100644
index 0000000000..94d57339b1
--- /dev/null
+++ b/indra/newview/scripts/lua/test_screen_position.lua
@@ -0,0 +1,8 @@
+LLAgent = require 'LLAgent'
+
+local screen_pos = LLAgent.getAgentScreenPos()
+if screen_pos.onscreen then
+  print("Avatar screen coordinates X: " .. screen_pos.x .. " Y: " .. screen_pos.y)
+else
+  print("Avatar is not on the screen")
+end
diff --git a/indra/newview/scripts/lua/test_toolbars.lua b/indra/newview/scripts/lua/test_toolbars.lua
index 7683fca8a3..9cd1043446 100644
--- a/indra/newview/scripts/lua/test_toolbars.lua
+++ b/indra/newview/scripts/lua/test_toolbars.lua
@@ -20,7 +20,7 @@ if response == 'OK' then
         UI.removeToolbarBtn(BUTTONS[i])
       end
     end
-    popup:tip('Toolbars were reshuffled')
+    UI.popup:tip('Toolbars were reshuffled')
 else
-    popup:tip('Canceled')
+    UI.popup:tip('Canceled')
 end
diff --git a/indra/newview/skins/default/xui/da/sidepanel_item_info.xml b/indra/newview/skins/default/xui/da/sidepanel_item_info.xml
index d52845160b..6a2acfedf7 100644
--- a/indra/newview/skins/default/xui/da/sidepanel_item_info.xml
+++ b/indra/newview/skins/default/xui/da/sidepanel_item_info.xml
@@ -15,6 +15,9 @@
 	<panel.string name="acquiredDate">
 		[wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
 	</panel.string>
+  <panel.string name="acquiredDateAMPM">
+    [wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local] [year,datetime,local]
+  </panel.string>
 	<panel.string name="origin_inventory">
 		(Beholdning)
 	</panel.string>
diff --git a/indra/newview/skins/default/xui/de/floater_about_land.xml b/indra/newview/skins/default/xui/de/floater_about_land.xml
index bb9ab26ef5..9c93ff38ad 100644
--- a/indra/newview/skins/default/xui/de/floater_about_land.xml
+++ b/indra/newview/skins/default/xui/de/floater_about_land.xml
@@ -25,7 +25,8 @@
 			<panel.string name="none_text">(keiner)</panel.string>
 			<panel.string name="sale_pending_text">(Wird verkauft)</panel.string>
 			<panel.string name="no_selection_text">Keine Parzelle ausgewählt.</panel.string>
-			<panel.string name="time_stamp_template">[wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]</panel.string>
+			<panel.string name="time_stamp_template_ampm">[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,slt]</panel.string>
+			<panel.string name="time_stamp_template">[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]</panel.string>
 			<text name="Name:">Name:</text>
 			<text name="Description:">Beschreibung:</text>
 			<text name="LandType">Typ:</text>
diff --git a/indra/newview/skins/default/xui/de/floater_inspect.xml b/indra/newview/skins/default/xui/de/floater_inspect.xml
index da97ceb2d8..a193e1123e 100644
--- a/indra/newview/skins/default/xui/de/floater_inspect.xml
+++ b/indra/newview/skins/default/xui/de/floater_inspect.xml
@@ -1,7 +1,10 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <floater min_width="460" name="inspect" title="OBJEKTE UNTERSUCHEN" width="460">
+	<floater.string name="timeStampAMPM">
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,slt]
+	</floater.string>
 	<floater.string name="timeStamp">
-		[wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]
 	</floater.string>
 	<scroll_list name="object_list" tool_tip="Wählen Sie ein Objekt aus dieser Liste, um es in der Second Life-Welt zu markieren">
 		<scroll_list.columns label="Objektname" name="object_name"/>
diff --git a/indra/newview/skins/default/xui/de/panel_classified_info.xml b/indra/newview/skins/default/xui/de/panel_classified_info.xml
index 007e9d69f0..1b8caf5f78 100644
--- a/indra/newview/skins/default/xui/de/panel_classified_info.xml
+++ b/indra/newview/skins/default/xui/de/panel_classified_info.xml
@@ -13,7 +13,7 @@
 		[TELEPORT] teleportieren, [MAP] Karte, [PROFILE] Profil
 	</panel.string>
 	<panel.string name="date_fmt">
-		[mthnum,datetime,slt]/[day,datetime,slt]/[year,datetime,slt]
+		[day,datetime,slt].[mthnum,datetime,slt].[year,datetime,slt]
 	</panel.string>
 	<panel.string name="auto_renew_on">
 		Aktiviert
diff --git a/indra/newview/skins/default/xui/de/panel_landmark_info.xml b/indra/newview/skins/default/xui/de/panel_landmark_info.xml
index 10cf34c170..8726d5e645 100644
--- a/indra/newview/skins/default/xui/de/panel_landmark_info.xml
+++ b/indra/newview/skins/default/xui/de/panel_landmark_info.xml
@@ -15,8 +15,11 @@
 	<string name="server_forbidden_text">
 		Die Informationen über diesen Standort sind zugriffsbeschränkt.  Bitte wenden Sie sich bezüglich Ihrer Berechtigungen an den Eigentümer der Parzelle.
 	</string>
+	<string name="acquired_date_ampm">
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local]
+	</string>
 	<string name="acquired_date">
-		[wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]
 	</string>
 	<button name="back_btn" tool_tip="Hinten"/>
 	<text name="title" value="Ortsprofil"/>
diff --git a/indra/newview/skins/default/xui/de/panel_place_profile.xml b/indra/newview/skins/default/xui/de/panel_place_profile.xml
index 4077fdab36..a0b5a1e9dc 100644
--- a/indra/newview/skins/default/xui/de/panel_place_profile.xml
+++ b/indra/newview/skins/default/xui/de/panel_place_profile.xml
@@ -38,8 +38,11 @@
 	<string name="server_forbidden_text">
 		Die Informationen über diesen Standort sind zugriffsbeschränkt.  Bitte wenden Sie sich bezüglich Ihrer Berechtigungen an den Eigentümer der Parzelle.
 	</string>
+	<string name="acquired_date_ampm">
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local]
+	</string>
 	<string name="acquired_date">
-		[wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]
 	</string>
 	<button name="back_btn" tool_tip="Hinten"/>
 	<text name="title" value="Ortsprofil"/>
diff --git a/indra/newview/skins/default/xui/de/panel_profile_classified.xml b/indra/newview/skins/default/xui/de/panel_profile_classified.xml
index 5c11a01977..5a4b42870c 100644
--- a/indra/newview/skins/default/xui/de/panel_profile_classified.xml
+++ b/indra/newview/skins/default/xui/de/panel_profile_classified.xml
@@ -13,7 +13,7 @@
 		[TELEPORT] Teleportieren, [MAP] Karten, [PROFILE] Profil
 	</panel.string>
 	<panel.string name="date_fmt">
-		[mthnum,datetime,slt]/[day,datetime,slt]/[year,datetime,slt]
+		[day,datetime,slt].[mthnum,datetime,slt].[year,datetime,slt]
 	</panel.string>
 	<panel.string name="auto_renew_on">
 		Aktiviert
diff --git a/indra/newview/skins/default/xui/de/panel_profile_secondlife.xml b/indra/newview/skins/default/xui/de/panel_profile_secondlife.xml
index baaa58e1d7..437cde99fe 100644
--- a/indra/newview/skins/default/xui/de/panel_profile_secondlife.xml
+++ b/indra/newview/skins/default/xui/de/panel_profile_secondlife.xml
@@ -1,5 +1,11 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <panel label="Profil" name="panel_profile">
+	<string
+	 name="date_format_full"
+	 value="SL-Geburtstag: [day,datetime,utc]. [mth,datetime,utc]. [year,datetime,utc]" />
+	<string
+	 name="date_format_short"
+	 value="SL-Geburtstag: [day,datetime,utc]. [mth,datetime,utc]." />
 	<string name="status_online">
 		Zurzeit online
 	</string>
diff --git a/indra/newview/skins/default/xui/de/panel_status_bar.xml b/indra/newview/skins/default/xui/de/panel_status_bar.xml
index 0829814220..e017c6dd82 100644
--- a/indra/newview/skins/default/xui/de/panel_status_bar.xml
+++ b/indra/newview/skins/default/xui/de/panel_status_bar.xml
@@ -10,7 +10,7 @@
 		[hour12, datetime, slt]:[min, datetime, slt] [ampm, datetime, slt] [timezone,datetime, slt]
 	</panel.string>
 	<panel.string name="timeTooltip">
-		[weekday, datetime, slt], [day, datetime, slt] [month, datetime, slt] [year, datetime, slt]
+		[weekday, datetime, slt], [day, datetime, slt]. [month, datetime, slt] [year, datetime, slt]
 	</panel.string>
 	<panel.string name="buycurrencylabel">
 		[AMT] L$
diff --git a/indra/newview/skins/default/xui/de/sidepanel_item_info.xml b/indra/newview/skins/default/xui/de/sidepanel_item_info.xml
index 168bb14248..30886d1433 100644
--- a/indra/newview/skins/default/xui/de/sidepanel_item_info.xml
+++ b/indra/newview/skins/default/xui/de/sidepanel_item_info.xml
@@ -19,7 +19,10 @@
 		Eigentümer kann:
 	</panel.string>
 	<panel.string name="acquiredDate">
-		[wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]
+	</panel.string>
+	<panel.string name="acquiredDateAMPM">
+		[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local] 
 	</panel.string>
 	<panel.string name="origin_inventory">
 		(Inventar)
diff --git a/indra/newview/skins/default/xui/de/strings.xml b/indra/newview/skins/default/xui/de/strings.xml
index 486d604e9f..8464bd9b0c 100644
--- a/indra/newview/skins/default/xui/de/strings.xml
+++ b/indra/newview/skins/default/xui/de/strings.xml
@@ -39,7 +39,7 @@ Audiotreiberversion: [AUDIO_DRIVER_VERSION]
 LibVLC-Version: [LIBVLC_VERSION]
 Voice-Server-Version: [VOICE_VERSION]</string>
 	<string name="AboutTraffic">Paketverlust: [PACKETS_LOST,number,0]/[PACKETS_IN,number,0] ([PACKETS_PCT,number,1] %)</string>
-	<string name="AboutTime">[month, datetime, slt] [day, datetime, slt] [year, datetime, slt] [hour, datetime, slt]:[min, datetime, slt]:[second,datetime,slt]</string>
+	<string name="AboutTime">[day, datetime, slt]. [month, datetime, slt] [year, datetime, slt] [hour, datetime, slt]:[min, datetime, slt]:[second,datetime,slt]</string>
 	<string name="ErrorFetchingServerReleaseNotesURL">Fehler beim Abrufen der URL für die Server-Versionshinweise.</string>
 	<string name="BuildConfiguration">Build-Konfiguration</string>
 	<string name="ProgressRestoring">Wird wiederhergestellt...</string>
@@ -812,7 +812,7 @@ Falls diese Meldung weiterhin angezeigt wird, wenden Sie sich unter http://suppo
 	<string name="Unknown">(unbekannt)</string>
 	<string name="SummaryForTheWeek" value="Zusammenfassung für diese Woche, beginnend am "/>
 	<string name="NextStipendDay" value=". Der nächste Stipendium-Tag ist "/>
-	<string name="GroupPlanningDate">[mthnum,datetime,utc]/[day,datetime,utc]/[year,datetime,utc]</string>
+	<string name="GroupPlanningDate">[day,datetime,utc].[mthnum,datetime,utc].[year,datetime,utc]</string>
 	<string name="GroupIndividualShare" value="                      Gruppenanteil       Einzelanteil"/>
 	<string name="GroupColumn" value="Gruppe"/>
 	<string name="Balance">Kontostand</string>
@@ -961,7 +961,7 @@ Falls diese Meldung weiterhin angezeigt wird, wenden Sie sich unter http://suppo
 	<string name="GroupMoneyBalance">Kontostand</string>
 	<string name="GroupMoneyCredits">Danksagung</string>
 	<string name="GroupMoneyDebits">Soll</string>
-	<string name="GroupMoneyDate">[weekday,datetime,utc] [mth,datetime,utc] [day,datetime,utc], [year,datetime,utc]</string>
+	<string name="GroupMoneyDate">[weekday,datetime,utc] [day,datetime,utc]. [mth,datetime,utc]. [year,datetime,utc]</string>
 	<string name="AcquiredItems">Erworbene Artikel</string>
 	<string name="Cancel">Abbrechen</string>
 	<string name="UploadingCosts">Das Hochladen von [NAME] kostet [AMOUNT] L$</string>
@@ -1765,7 +1765,7 @@ Missbrauchsbericht</string>
 	<string name="dance6">Tanzen6</string>
 	<string name="dance7">Tanzen7</string>
 	<string name="dance8">Tanzen8</string>
-	<string name="AvatarBirthDateFormat">[mthnum,datetime,slt]/[day,datetime,slt]/[year,datetime,slt]</string>
+	<string name="AvatarBirthDateFormat">[day,datetime,slt].[mthnum,datetime,slt].[year,datetime,slt]</string>
 	<string name="DefaultMimeType">Keine/Keiner</string>
 	<string name="texture_load_dimensions_error">Bilder, die größer sind als [WIDTH]*[HEIGHT] können nicht geladen werden</string>
 	<string name="outfit_photo_load_dimensions_error">Max. Fotogröße für Outfit ist [WIDTH]*[HEIGHT]. Bitte verkleinern Sie das Bild oder verwenden Sie ein anderes.</string>
diff --git a/indra/newview/skins/default/xui/en/floater_about_land.xml b/indra/newview/skins/default/xui/en/floater_about_land.xml
index 508aba6ae1..c5b42b6dae 100644
--- a/indra/newview/skins/default/xui/en/floater_about_land.xml
+++ b/indra/newview/skins/default/xui/en/floater_about_land.xml
@@ -125,6 +125,9 @@
              name="no_selection_text">
                 No parcel selected.
             </panel.string>
+            <panel.string name="time_stamp_template_ampm">
+              [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour12,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [ampm,datetime,slt] [year,datetime,slt]
+            </panel.string>
             <panel.string name="time_stamp_template">
               [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [year,datetime,slt]
             </panel.string>
diff --git a/indra/newview/skins/default/xui/en/floater_inspect.xml b/indra/newview/skins/default/xui/en/floater_inspect.xml
index 9403d58441..a083683c23 100644
--- a/indra/newview/skins/default/xui/en/floater_inspect.xml
+++ b/indra/newview/skins/default/xui/en/floater_inspect.xml
@@ -12,6 +12,10 @@
  title="INSPECT OBJECTS"
  width="400">
     <floater.string
+     name="timeStampAMPM">
+      [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour12,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [ampm,datetime,slt] [year,datetime,slt]
+    </floater.string>
+    <floater.string
      name="timeStamp">
         [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [year,datetime,slt]
     </floater.string>
diff --git a/indra/newview/skins/default/xui/en/floater_inventory_item_properties.xml b/indra/newview/skins/default/xui/en/floater_inventory_item_properties.xml
index 6c3214a76d..1aa216d6b4 100644
--- a/indra/newview/skins/default/xui/en/floater_inventory_item_properties.xml
+++ b/indra/newview/skins/default/xui/en/floater_inventory_item_properties.xml
@@ -28,6 +28,10 @@
      name="acquiredDate">
         [wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
     </floater.string>
+    <floater.string
+     name="acquiredDateAMPM">
+        [wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local] [year,datetime,local]
+    </floater.string>
     <icon
      follows="top|right"
      height="18"
diff --git a/indra/newview/skins/default/xui/en/floater_lua_debug.xml b/indra/newview/skins/default/xui/en/floater_lua_debug.xml
index 15027f1647..5efe1c958a 100644
--- a/indra/newview/skins/default/xui/en/floater_lua_debug.xml
+++ b/indra/newview/skins/default/xui/en/floater_lua_debug.xml
@@ -25,6 +25,17 @@
      width="100">
       LUA string:
     </text>
+    <check_box
+     control_name="LuaDebugShowSource"
+     follows="right|top"
+     height="15"
+     label="Show source info"
+     layout="topleft"
+     top="10"
+     right ="-70"
+     tool_tip="Show source info in Lua Debug Console output"
+     name="show_script_name"
+     width="70"/>
     <line_editor
      border_style="line"
      border_thickness="1"
diff --git a/indra/newview/skins/default/xui/en/floater_rlv_console.xml b/indra/newview/skins/default/xui/en/floater_rlv_console.xml
new file mode 100644
index 0000000000..708055d1b6
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/floater_rlv_console.xml
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+ can_resize="true"
+ height="400"
+ layout="topleft"
+ min_height="300"
+ min_width="300"
+ name="rlv_console"
+ title="RLVa console"
+ width="600"
+ >
+    <layout_stack
+     animate="false"
+     bottom="-1"
+     default_tab_group="2"
+     follows="all"
+     left="5"
+     layout="topleft"
+     mouse_opaque="false"
+     name="main_stack"
+     right="-5"
+     orientation="vertical"
+     tab_group="1"
+     top="1"
+     >
+        <layout_panel
+         name="body_panel"
+         height="235">
+            <text_editor
+             follows="all"
+             left="1"
+			 right="-1"
+			 top="0"
+             length="1"
+             font="Monospace"
+             bottom="-1"
+             ignore_tab="false"
+             layout="topleft"
+             max_length="65536"
+             name="console_output"
+             read_only="true"
+             track_end="true"
+             type="string"
+             word_wrap="true"
+            >
+            </text_editor>
+        </layout_panel>
+
+        <layout_panel
+         height="26"
+         auto_resize="false"
+         name="input_panel">
+            <chat_editor
+             layout="topleft"
+             expand_lines_count="5"
+             follows="left|right|bottom"
+             font="SansSerifSmall"
+             height="20"
+             is_expandable="true"
+             text_tentative_color="TextFgTentativeColor"
+             name="console_input"
+             max_length="1023"
+             spellcheck="true"
+             tab_group="3"
+             bottom_delta="20"
+             left="1"
+			 top="1"
+			 right="-1"
+             show_emoji_helper="false"
+             wrap="true"
+            />
+        </layout_panel>
+    </layout_stack>
+</floater>
diff --git a/indra/newview/skins/default/xui/en/floater_world_map.xml b/indra/newview/skins/default/xui/en/floater_world_map.xml
index 5ab0177de6..6883ec1cd0 100644
--- a/indra/newview/skins/default/xui/en/floater_world_map.xml
+++ b/indra/newview/skins/default/xui/en/floater_world_map.xml
@@ -109,7 +109,7 @@
     </panel>
     <panel
      follows="right|top"
-     height="126"
+     height="150"
      top_pad="4"
      width="238"
      left="1"
@@ -285,6 +285,29 @@
        by owner
     </text>
 
+    <check_box
+     name="grid_coords_chk"
+     control_name="MapShowGridCoords"
+     layout="topleft"
+     follows="top|right"
+     top_pad="2"
+     left="3"
+     height="16"
+     width="22"
+    />
+    <text
+     name="grid_coords_label"
+     type="string"
+     layout="topleft"
+     follows="top|right"
+     top_delta="2"
+     left_pad="3"
+     height="16"
+     width="220"
+     halign="left"
+     length="1"
+    >Show grid map coordinates</text>
+
     <button
      follows="top|right"
      height="22"
@@ -455,7 +478,7 @@
 
     <panel
      follows="right|top|bottom"
-	 height="330"
+     height="306"
 	 top_pad="0"
 	 width="238"
 	 name="layout_panel_4">
@@ -576,7 +599,7 @@
      draw_stripes="false"
      bg_writeable_color="MouseGray"
      follows="all"
-     height="145"
+     height="121"
      layout="topleft"
      left="28"
      name="search_results"
diff --git a/indra/newview/skins/default/xui/en/menu_viewer.xml b/indra/newview/skins/default/xui/en/menu_viewer.xml
index da9cc0c98d..53615968e0 100644
--- a/indra/newview/skins/default/xui/en/menu_viewer.xml
+++ b/indra/newview/skins/default/xui/en/menu_viewer.xml
@@ -562,25 +562,6 @@
         </menu_item_check>
         <menu_item_separator/>
         <menu_item_check
-          label="Hear Media and Sound from Avatar"
-          name="Hear Media and Sound from Avatar">
-            <menu_item_check.on_check
-             control="MediaSoundsEarLocation" />
-            <menu_item_check.on_click
-             function="Agent.ToggleHearMediaSoundFromAvatar" />
-        </menu_item_check>
-        <menu_item_check
-          label="Hear Voice from Avatar"
-          name="Hear Voice from Avatar">
-            <menu_item_check.on_check
-             control="VoiceEarLocation" />
-            <menu_item_check.on_click
-             function="Agent.ToggleHearVoiceFromAvatar" />
-            <menu_item_call.on_enable
-             control="EnableVoiceChat" />
-        </menu_item_check>
-        <menu_item_separator/>
-        <menu_item_check
          label="Gestures..."
          name="Gestures"
          shortcut="control|G">
@@ -1838,6 +1819,71 @@ function="World.EnvPreset"
     </menu>
     <menu
      create_jump_keys="true"
+     label="RLVa"
+     name="RLVa Main"
+     tear_off="true"
+     visible="true">
+      <menu
+       label="Debug"
+       name="Debug"
+       tear_off="true">
+        <menu_item_check
+         label="Show Top-level RLVa Menu"
+         name="Show Top-level RLVa Menu">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaTopLevelMenu" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaTopLevelMenu" />
+        </menu_item_check>
+      	<menu_item_separator/>
+      	<menu_item_check
+      	 label="Show Debug Messages"
+      	 name="Show Debug Messages">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RestrainedLoveDebug" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RestrainedLoveDebug" />
+      	</menu_item_check>
+      	<menu_item_check
+      	 label="Hide Unset or Duplicate Messages"
+      	 name="Hide Unset or Duplicate Messages">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaDebugHideUnsetDuplicate" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaDebugHideUnsetDuplicate" />
+      	</menu_item_check>
+      </menu>
+      <menu_item_separator/>
+      <menu_item_check
+       label="Allow Temporary Attachments"
+       name="Allow Temporary Attachments">
+      	<menu_item_check.on_check
+      	 function="CheckControl"
+      	 parameter="RLVaEnableTemporaryAttachments" />
+      	<menu_item_check.on_click
+      	 function="ToggleControl"
+      	 parameter="RLVaEnableTemporaryAttachments" />
+      </menu_item_check>
+      <menu_item_separator />
+      <menu_item_check
+       label="Console..."
+       name="Console">
+        <menu_item_check.on_check
+      	 function="Floater.Visible"
+      	 parameter="rlv_console" />
+        <menu_item_check.on_click
+      	 function="Floater.Toggle"
+      	 parameter="rlv_console" />
+      </menu_item_check>
+    </menu>
+    <menu
+     create_jump_keys="true"
      label="Advanced"
      name="Advanced"
      tear_off="true"
@@ -2343,7 +2389,12 @@ function="World.EnvPreset"
                  function="Advanced.ToggleFeature"
                  parameter="flexible" />
             </menu_item_check>
-        </menu>
+        </menu>        
+        <menu
+         label="RLVa"
+         name="RLVa Embedded"
+         tear_off="true"
+         visible="true" />
         <menu_item_check
          label="Use Plugin Read Thread"
          name="Use Plugin Read Thread">
@@ -3756,6 +3807,13 @@ function="World.EnvPreset"
             </menu_item_call>
             <menu_item_call
               enabled="true"
+              label="Edit Local Paintmap"
+              name="Edit Local Paintmap">
+              <menu_item_call.on_click
+               function="Advanced.TerrainEditLocalPaintMap" />
+            </menu_item_call>
+            <menu_item_call
+              enabled="true"
               label="Delete Local Paintmap"
               name="Delete Local Paintmap">
               <menu_item_call.on_click
diff --git a/indra/newview/skins/default/xui/en/notifications.xml b/indra/newview/skins/default/xui/en/notifications.xml
index 071f6458c5..4d74261a9a 100644
--- a/indra/newview/skins/default/xui/en/notifications.xml
+++ b/indra/newview/skins/default/xui/en/notifications.xml
@@ -1662,7 +1662,7 @@ The new skin will appear after you restart [APP_NAME].
    icon="alertmodal.tga"
    name="ChangeLanguage"
    type="alertmodal">
-Changing language will take effect after you restart [APP_NAME].
+Changing language or time format will take effect after you restart [APP_NAME].
   </notification>
 
   <notification
@@ -6532,6 +6532,22 @@ Do you want to replace it with the selected object?
   </notification>
 
   <notification
+   icon="alertmodal.tga"
+   name="CantLinkNotecard"
+   type="alertmodal">
+    You must save the notecard before creating a link to it.
+    <tag>fail</tag>
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+   name="CantLinkMaterial"
+   type="alertmodal">
+    You must save the material before creating a link to it.
+    <tag>fail</tag>
+  </notification>
+
+  <notification
    icon="alert.tga"
    label="Do Not Disturb Mode Warning"
    name="DoNotDisturbModePay"
diff --git a/indra/newview/skins/default/xui/en/panel_avatar_list_item.xml b/indra/newview/skins/default/xui/en/panel_avatar_list_item.xml
index ca6e94397d..53551b2f79 100644
--- a/indra/newview/skins/default/xui/en/panel_avatar_list_item.xml
+++ b/indra/newview/skins/default/xui/en/panel_avatar_list_item.xml
@@ -156,6 +156,5 @@
      mouse_opaque="true"
      name="speaking_indicator"
      tool_tip="Voice volume"
-     visible="true"
      width="20" />
 </panel>
diff --git a/indra/newview/skins/default/xui/en/panel_conversation_list_item.xml b/indra/newview/skins/default/xui/en/panel_conversation_list_item.xml
index 7902588598..e0b7f71321 100644
--- a/indra/newview/skins/default/xui/en/panel_conversation_list_item.xml
+++ b/indra/newview/skins/default/xui/en/panel_conversation_list_item.xml
@@ -91,7 +91,6 @@
 		     left_pad="5"
  		     mouse_opaque="true"
  		     name="speaking_indicator"
- 		     visible="false"
  		     width="20" />
         </layout_panel>
     </layout_stack>
diff --git a/indra/newview/skins/default/xui/en/panel_landmark_info.xml b/indra/newview/skins/default/xui/en/panel_landmark_info.xml
index af68bd7fee..19599efdc2 100644
--- a/indra/newview/skins/default/xui/en/panel_landmark_info.xml
+++ b/indra/newview/skins/default/xui/en/panel_landmark_info.xml
@@ -40,6 +40,10 @@
         Information about this location is unavailable due to access restrictions.  Please check your permissions with the parcel owner.
     </string>
     <string
+     name="acquired_date_ampm">
+        [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour12,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [ampm,datetime,slt] [year,datetime,slt]
+    </string>
+    <string
      name="acquired_date">
         [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [year,datetime,slt]
     </string>
diff --git a/indra/newview/skins/default/xui/en/panel_nearby_chat_bar.xml b/indra/newview/skins/default/xui/en/panel_nearby_chat_bar.xml
index 1a89d07cbb..48f6580d61 100644
--- a/indra/newview/skins/default/xui/en/panel_nearby_chat_bar.xml
+++ b/indra/newview/skins/default/xui/en/panel_nearby_chat_bar.xml
@@ -34,7 +34,6 @@
      mouse_opaque="true"
      name="chat_zone_indicator"
      top="6"
-     visible="true"
      width="20" />
     <button
      follows="right"
diff --git a/indra/newview/skins/default/xui/en/panel_place_profile.xml b/indra/newview/skins/default/xui/en/panel_place_profile.xml
index 8f5292c531..bb877080b1 100644
--- a/indra/newview/skins/default/xui/en/panel_place_profile.xml
+++ b/indra/newview/skins/default/xui/en/panel_place_profile.xml
@@ -89,6 +89,10 @@
         Information about this location is unavailable due to access restrictions.  Please check your permissions with the parcel owner.
     </string>
     <string
+     name="acquired_date_ampm">
+        [wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local] [year,datetime,local]
+    </string>
+    <string
      name="acquired_date">
         [wkday,datetime,local] [mth,datetime,local] [day,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local] [year,datetime,local]
     </string>
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_general.xml b/indra/newview/skins/default/xui/en/panel_preferences_general.xml
index 101c506309..ddddb4855f 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_general.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_general.xml
@@ -91,6 +91,37 @@
          name="Traditional Chinese"
          value="zh" />
     </combo_box>
+   <text
+     type="string"
+     length="1"
+     follows="left|top"
+     height="15"
+     layout="topleft"
+     left="255"
+     name="time_format_textbox"
+     top="10"
+     width="200">
+        Time Format:
+    </text>
+    <combo_box
+     follows="left|top"
+     height="23"
+     layout="topleft"
+     left="255"
+     max_chars="135"
+     name="time_format_combobox"
+     width="70">
+        <combo_box.item
+         enabled="true"
+         label="1:00 AM"
+         name="12H"
+         value="0" />
+        <combo_box.item
+         enabled="true"
+         label="13:00"
+         name="24H"
+         value="1" />
+    </combo_box>
     <text
  font="SansSerifSmall"
      type="string"
diff --git a/indra/newview/skins/default/xui/en/panel_region_general.xml b/indra/newview/skins/default/xui/en/panel_region_general.xml
index 6ef1b6e44a..47e1e669d1 100644
--- a/indra/newview/skins/default/xui/en/panel_region_general.xml
+++ b/indra/newview/skins/default/xui/en/panel_region_general.xml
@@ -33,6 +33,28 @@
         unknown
     </text>
     <text
+     follows="right|top"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     top_delta="0"
+     right="-100"
+     name="estate_id_lbl"
+     width="80">
+        Estate ID:
+    </text>
+    <line_editor
+     follows="right|top"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     top_delta="0"
+     name="estate_id"
+     enabled="false"
+     right="-10"
+     initial_value="unknown"
+     width="85" />
+    <text
      follows="left|top"
      font="SansSerif"
      height="20"
@@ -55,6 +77,39 @@
         unknown
     </text>
     <text
+     follows="right|top"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     top_delta="0"
+     right="-100"
+     name="grid_position_lbl"
+     width="80">
+        Grid Position:
+    </text>
+    <line_editor
+     follows="right|top"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     right="-55"
+     name="grid_position_x"
+     enabled="false"
+     top_delta="0"
+     default_text="n/a"
+     width="40" />
+    <line_editor
+     follows="right|top"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     right="-10"
+     name="grid_position_y"
+     enabled="false"
+     top_delta="0"
+     default_text="n/a"
+     width="40" />
+    <text
      follows="left|top"
      font="SansSerif"
      height="20"
diff --git a/indra/newview/skins/default/xui/en/sidepanel_item_info.xml b/indra/newview/skins/default/xui/en/sidepanel_item_info.xml
index 1cb3eca2eb..40a88d4121 100644
--- a/indra/newview/skins/default/xui/en/sidepanel_item_info.xml
+++ b/indra/newview/skins/default/xui/en/sidepanel_item_info.xml
@@ -32,6 +32,10 @@
     Owner can:
   </panel.string>
   <panel.string
+    name="acquiredDateAMPM">
+    [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour12,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [ampm,datetime,slt] [year,datetime,slt]
+  </panel.string>
+  <panel.string
     name="acquiredDate">
     [wkday,datetime,slt] [mth,datetime,slt] [day,datetime,slt] [hour,datetime,slt]:[min,datetime,slt]:[second,datetime,slt] [year,datetime,slt]
   </panel.string>
diff --git a/indra/newview/skins/default/xui/en/strings.xml b/indra/newview/skins/default/xui/en/strings.xml
index effd19b708..3ec4b7205b 100644
--- a/indra/newview/skins/default/xui/en/strings.xml
+++ b/indra/newview/skins/default/xui/en/strings.xml
@@ -60,6 +60,7 @@ Disk cache: [DISK_CACHE_INFO]
 HiDPI display mode: [HIDPI]
 	</string>
 	<string name="AboutLibs">
+RestrainedLove API: [RLV_VERSION]
 J2C Decoder Version: [J2C_VERSION]
 Audio Driver Version: [AUDIO_DRIVER_VERSION]
 [LIBCEF_VERSION]
@@ -4381,4 +4382,31 @@ and report the problem.
 [https://community.secondlife.com/knowledgebase/english/error-messages-r520/#Section__3 Knowledge Base]
   </string>
 
+  <!-- RLVa -->
+  <string name="RlvConsoleDisable">RLVa is disabled</string>
+  <string name="RlvConsoleInvalidCmd">Invalid command</string>
+  <string name="RlvConsoleExecuted">INFO</string>
+  <string name="RlvConsoleFailed">ERR</string>
+  <string name="RlvConsoleRetained">RET</string>
+  <string name="RlvDebugExecuted">executed</string>
+  <string name="RlvDebugFailed">failed</string>
+  <string name="RlvDebugRetained">retained</string>
+  <string name="RlvReturnCodeUnset">unset</string>
+  <string name="RlvReturnCodeDuplicate">duplicate</string>
+  <string name="RlvReturnCodeDelayed">delayed</string>
+  <string name="RlvReturnCodeDeprecated">deprecated</string>
+  <string name="RlvReturnCodeSyntax">thingy error</string>
+  <string name="RlvReturnCodeOption">invalid option</string>
+  <string name="RlvReturnCodeParam">invalid param</string>
+  <string name="RlvReturnCodeLock">locked command</string>
+  <string name="RlvReturnCodeDisabled">disabled command</string>
+  <string name="RlvReturnCodeUnknown">unknown command</string>
+  <string name="RlvReturnCodeNoSharedRoot">missing #RLV</string>
+  <string name="RlvReturnCodeDeprecatedAndDisabled">deprecated and disabled</string>
+  <string name="RlvReturnCodeNoBehaviour">no active behaviours</string>
+  <string name="RlvReturnCodeUnheldBehaviour">base behaviour not held</string>
+  <string name="RlvReturnCodeBlocked">blocked object</string>
+  <string name="RlvReturnCodeThrottled">throttled</string>
+  <string name="RlvReturnCodeNoProcessor">no command processor found</string>
+
 </strings>
diff --git a/indra/newview/skins/default/xui/en/widgets/conversation_view_participant.xml b/indra/newview/skins/default/xui/en/widgets/conversation_view_participant.xml
index cf995e5833..180071a321 100644
--- a/indra/newview/skins/default/xui/en/widgets/conversation_view_participant.xml
+++ b/indra/newview/skins/default/xui/en/widgets/conversation_view_participant.xml
@@ -37,6 +37,5 @@
 	right="-3"
 	mouse_opaque="true"
 	name="speaking_indicator"
-	visible="true"
-	width="20" />	 
+	width="20" />
 </conversation_view_participant>
diff --git a/indra/newview/skins/default/xui/en/widgets/output_monitor.xml b/indra/newview/skins/default/xui/en/widgets/output_monitor.xml
index 788c733ca8..10e39fa030 100644
--- a/indra/newview/skins/default/xui/en/widgets/output_monitor.xml
+++ b/indra/newview/skins/default/xui/en/widgets/output_monitor.xml
@@ -10,4 +10,5 @@
   image_level_3="VoicePTT_Lvl3"
   mouse_opaque="false"
   name="output_monitor"
+  visible="false"
   />
diff --git a/indra/newview/skins/default/xui/en/widgets/person_view.xml b/indra/newview/skins/default/xui/en/widgets/person_view.xml
index 82dbdf0dab..e07f340be1 100644
--- a/indra/newview/skins/default/xui/en/widgets/person_view.xml
+++ b/indra/newview/skins/default/xui/en/widgets/person_view.xml
@@ -111,7 +111,6 @@
       right="-3"
       mouse_opaque="true"
       name="speaking_indicator"
-      visible="false"
       width="20" />
  </person_view>
 
diff --git a/indra/newview/tests/llworldmap_test.cpp b/indra/newview/tests/llworldmap_test.cpp
index d5bf189d82..99c98f63ed 100644
--- a/indra/newview/tests/llworldmap_test.cpp
+++ b/indra/newview/tests/llworldmap_test.cpp
@@ -28,6 +28,7 @@
 // Dependencies
 #include "linden_common.h"
 #include "llapr.h"
+#include "llcontrol.h"      // LLControlGroup
 #include "llsingleton.h"
 #include "lltrans.h"
 #include "lluistring.h"
@@ -71,6 +72,8 @@ void LLUIString::updateResult() const { }
 void LLUIString::setArg(const std::string& , const std::string& ) { }
 void LLUIString::assign(const std::string& ) { }
 
+LLControlGroup gSavedSettings("Global");    // saved at end of session
+
 // End Stubbing
 // -------------------------------------------------------------------------------------------
 
@@ -131,6 +134,7 @@ namespace tut
         // Constructor and destructor of the test wrapper
         worldmap_test()
         {
+            gSavedSettings.declareBOOL("Use24HourClock", true, "", LLControlVariable::PERSIST_NO);
             mWorld = LLWorldMap::getInstance();
         }
         ~worldmap_test()
diff --git a/indra/test/sync.h b/indra/test/sync.h
index 82eef1e5f5..abeb4e17a8 100644
--- a/indra/test/sync.h
+++ b/indra/test/sync.h
@@ -69,7 +69,7 @@ public:
         // misleading, as it will be emitted after waiting threads have
         // already awakened. But emitting the log message within the lock
         // would seem to hold the lock longer than we really ought.
-        LL_DEBUGS() << llcoro::logname() << " bump(" << n << ") -> " << updated << LL_ENDL;
+        LL_DEBUGS() << LLCoros::getName() << " bump(" << n << ") -> " << updated << LL_ENDL;
     }
 
     /**
@@ -82,7 +82,7 @@ public:
      */
     void set(int n)
     {
-        LL_DEBUGS() << llcoro::logname() << " set(" << n << ")" << LL_ENDL;
+        LL_DEBUGS() << LLCoros::getName() << " set(" << n << ")" << LL_ENDL;
         mCond.set_all(n);
     }
 
@@ -101,7 +101,7 @@ public:
 private:
     void yield_until(const char* func, int arg, int until)
     {
-        std::string name(llcoro::logname());
+        std::string name(LLCoros::getName());
         LL_DEBUGS() << name << " yield_until(" << until << ") suspending" << LL_ENDL;
         if (! mCond.wait_for_equal(mTimeout, until))
         {
author	Nat Goodspeed <nat@lindenlab.com>	2024-10-22 14:46:15 -0400
committer	Nat Goodspeed <nat@lindenlab.com>	2024-10-22 14:46:15 -0400
commit	bfe759584f63c0587a2dc6a0086ad9d5b6c63a56 (patch)
tree	84653a1211908c7dd2ce5bc4877e79f8e6515099 /indra
parent	62fc3ceaf5251458239f91192a05edc64bedf33b (diff)
parent	394f7b37f2ec05c7cfb32c350432886f1c493c85 (diff)