 I am a designer primarily I also develop on the site for android on the web, but designs completely my passion I am still doing engineering I am in second year long way to go very difficult aside from college I am also I am co-founding my own company and I am consulting for a company use. Before we dive in quickly ask how many people have heard of mutated design ok great one. So visit the material design website I hope so yes any knows good so front and center of the material design website Google says design for the user and everything else will follow this philosophy portrays that if we keep the user at mind and focus on user centric design where every decision we take and every UI element we put in place is designed to make the user experience simpler and more efficient everything else will fall into place later because if the user will use the app well it means the product is successful. What does that make sense because if we say design for the user that is us effectively classifying the entire world's population into one user and then going on to define for the user. Now we have diversity sets so varied where we can factor in things like age gender race outlooks touch accuracy color blindness and other things like this now a set so diverse it is not right to combine that into one user and then say design for that user because then we are not keeping everyone else's needs in mind even if you are conducting testing A B testing between two features in your app and using a really positive outlook where one set has like perhaps 75% ratio of working and the other one has 25% ratio even if you say that's a good ratio between the two like one is really much higher and you go on to design for using that principle basically ignoring a quarter of your user base which is a quarter is a significant number classifying a diverse population that's online into one user and then designing for that according to Google's design for the user philosophy is something that is not really correct of us to do as designers and developers what someone asked what should we do that's what the whole topic is about. So this leads to the principle of something called mutated design before we dive into what mutated design is if we can start with a back story which will help us understand it better. So the pioneer of mutated design is a Google expert called Liam Spreadman from New York and his journey began when he met a woman with MS. MS is a degenerative disease which attacks the nervous system and it doesn't let you really use your smartphone with the best accuracy. She had a device and she was attempting to place a call but because of her nervous system problems her touch accuracy wasn't really so great she was clicking constantly and narrowing the wrong numbers and had an overall poor experience and his solution at the moment was to fix it just to give her a device with voice acting enabled but she would quickly tell the device to call someone and go ahead and do it. The second thing that triggered the idea of mutated design in him was she was hired to design an app for children. Now even though the client was looking to target an entire audience between 2 to 15 years old that's really volatile audience is because there are you see some toddlers who can barely touch this thing to mature teenagers who are who are much more the advanced features of it. Now how can you design one app for that entire set of users? You can say perhaps design for the easiest interface possible large buttons colorful UI for the youngest set of users because they are the ones who are going to have the most difficulty but if you only design for them and keep those things in mind providing a dumbed down experience to the users who actually know how these things work. So sacrificing their experience at the cost of some and you are not getting the entire user base. This brings us to mutated design. Mutated design is theoretical design methodology for user interface and user experiences There are born, live and evolve according to the user's reality. Simply put it is a design philosophy that aims to tailor an app's design that's specific to user. Each user will have the app installed but each user will have the experience differently tailored to their needs, their wants and their abilities. Let's get into the concept of mutated design. We mentioned that a born, live and evolve according to user's reality. What is the user's reality? They are not just simply things like what we mentioned is and abilities. There are also things like immediate lighting, data availability, plus reason down. User behavior could be something like perhaps someone doesn't have the best user typing and they end up pressing the wrong buttons too often. Very common. User characteristics would be things users tend to do. User experiences would be perhaps using the app in sunlight and the screen isn't really visible. And theoretical personal information is stuff we can generally know probably from the Google account or from the device itself. This uses age and gender and preferences. It brings us to why mutated. So right now as designers and developers we have written problems. For example, let's pick up web designers. People who design hybrid apps. They have the cross-platform part of it nailed down. Because their design represents a cross-platform. That is set for them. So they focus on working across screen sizes, bunch of media queries in it. On the other hand app developers, their screen sizes hand in really well for them with the layout folders. So they focus on the cross-platform aspect of it. But then is that all? Are screen sizes and platforms the only things that we need to adapt to? It's not because the user is more important than just the device or the platform. They design for the user. We are forgetting that part and just getting to the device or platform that users using. Accessibility. Now, there's so many problems that happen in accessibility. Most of us tend to ignore it. Even if you pick up a few things like say we designed for colorblind users. So now most developers when they approach this they simply do things like a higher contrast perhaps not using red and green side by side. Most of us aren't even aware that there are four different types of colorblindness not just the ones that are mainstream. But keeping everything in mind four types of colorblindness different types of transparency and a whole bunch of accessibility features that would be done with the core user experience. Because you can't keep all of them in mind. Legacy easily. Is this familiar with technology? We know that if we were perhaps to put three lines in the top corner of the screen it would mean to swipe from the left and open an hamburger menu. What about this guy? A kid who is just not even a kid it could be an adult. Someone who is just exposed to technology and isn't really familiar with this that we have been living with since years. They don't know how things work they don't know what those three lines signify they don't know what a floating action button does. What about them? If we could design for them and perhaps don't use a navigation door and switch to tabs but where I have more work better than a navigation door then like I said earlier I don't mean on the experience for the power we just know the patterns. Mirai design methodology. Mirai design is broken down into three main parts. So first of them is characteristics versus extra characteristics. Characteristics are things that belong to the user and extra characteristics are things that belong around the user. So the ones on the left are characteristics like we talked about vision, age and touch accuracy and extra characteristics could be things like data availability, lighting conditions, sound etc. Quick look at this. So if we were to view this is the same app used in a bright lighting condition and a perfect lighting condition like perhaps the office environment. Now if this was using a light UI it would not really be visible in sunlight. Because everything moves all colors move towards white in sunlight. So this wouldn't really be a good experience if it views the white. This is one of the reasons it needs to be muted. The important thing while considering mutated design is that we need to differentiate between long term characteristics and short term behaviors. Take a quick example. So last night you are irritated with something or something in your mind and you are texting someone frantically because it is very urgent. And you end up typing a whole lot of buttons really quickly and attempting to get your message out. And if you have a mutated design framework picks that up and says that you don't have the clear search accuracy that fact would be wrong because your state of mind at the moment is temporary and not a permanent characteristic of you. So it is really important while considering mutated design to differentiate between long term characteristics and short term behaviors. Because designing for a short term behavior would ruin the mutated experience because it is not 100% translation of what the housing user characteristics are. This is something called the mother design. Now let's look at this. Suppose we were we mentioned about mutating in bright lighting. Suppose our solution to mutating to bright lighting is to make the color palette of the app darker. Now in this mother design will probably leave blue in the center. So mother design is the base that we build upon. It is the architectural foundation fundamental archetype of the entire app. It is established as a base and we go on to build upon that. So if you look at this example the user may never even see the blue which is the mother design because of the way it mutates according to the lighting conditions. So at the same time the light on the right would be the text color against it. So in a bright lighting condition you would perhaps have a darker background with light text on it. And as the user moves into better lighting conditions it will mutate towards a lighter background with dark accent. Mother design is important because it is starting point for all decisions that are made. It's light of the background and the app does not move away from it. That is something that cannot be mutated. Literations are performed upon it and the status states are the direction that you go after the mother design. If you look at this graph there are multiple status states. It could be something like this where based on the lighting you darken the color of the button or it could be something like the one on the right where the user uses familiarity with tech you use the text button instead of a floating action button. So status states are these mutations on the mother design which are formally established and based on certain criteria they go ahead and mutate. The status states are important because they are the first step of mutations. They are the can you pick up like for example lighting mutate from there. Going deeper the status states can combine and provide a clear experience like perhaps lighting is bad and the user is not familiar with tech it would provide a dark square button. The status states are the first mutations so there are some doubts coming about mutated design in your mind. So let's quickly address those. First is user confidence. When a lot of designers and developers are about mutated design their first thought is what will happen to the user experience if I change how the app looks or behaves while they are using it. The second doubt that could come is accounting for everything. Like I mentioned there are a lot of states that they have to be accounted for because we cannot account for all the possible states. Third is deciding when to mutate. We mentioned long term characteristics and short term behaviors and knowing which is when which is what and when to mutate upon that is another thing that needs to be kept in mind while being mutated design. But we get to this doubt later because as you dive more into it you understand why these things have to be kept in mind and why they make sense more sense in mutated design in the ways of mutated design itself. So let's have a look at Gaia. Gaia is something that aims to solve the accounting for everything problem. So Gaia is a theoretical mutation framework that is based upon a machine learning principle that attempts to employ machine learning in design and learn from these characteristics and behaviors and that you design mutate from there. So Gaia would exist at a framework level. Theoretically for now it only exists as a class but it would theoretically exist at a framework level. So apps would subscribe to this. So let's look at the app at the bottom. The app at the bottom is reporting that the user is touching a little to the right side of the button every time. So actually this is not the great. So Gaia would pick it up the first time. The app reports again that again he is touching it off the button. Gaia picks it up a second time. This would happen a few times until the framework is completely sure that yes this is not something temporary it would be in the search accuracy problem and it would allow the mutation to go ahead and perhaps increase the button size and move it a little bit in that direction. Now because of Gaia existing as a mutation design framework when the second app sends the same feedback the user's search accuracy is not a great it would not be the same number of cycles of verification but Gaia that is a definite problem. Perhaps in one or two passes Gaia already knows that how the user can understand this. Perhaps in one or two passes Gaia would give it the go ahead. If you need to mutate on this factor because this is a known problem. So Gaia allows the cycle of mutation to happen behind the scenes. It handles the entire getting feedback, employing the fix, getting feedback on the fix and perhaps course correcting if needed. So for now Gaia is a long way off but I talked about new spread in the beginning and he is developing an app called Selene. Selene is a note taking app that is primarily mutated design. It employs the color thing we talked about moving towards darker colors and bright lighting and it also uses Gaia as a class. So Selene is completely open source and it's a really great class of checkout. There are links at the end for those types. So it's a really great class of checkout because it shows you just how the framework is receiving the mutated design inputs and making a decision whether or not to mutate. So for now it exists in the class within the framework. But the community is pushing for it to become something bigger and something better at a more core level to allow multiple apps to subscribe to the same framework rather than each app learning multiple times about the user. So we've talked a lot about what it can do and what we should do but we haven't talked about anything actual but in detail how it actually would look in a real app. So let's pick up a sample set of how mutated design would change the user experience. The first is mutating for user familiarity. We talked about users who are not only familiar but take patterns. So in Selene this is how it has to exist. So if you open up the app and you have a look at the bottom right corner the floating action button to create a new node. Now for users who are familiar with tech they will know that by pressing the button they add a node. But for users who are not really familiar with the pattern of a plus it gives them a few seconds and after a few seconds if no new node has been created it establishes the fact that the user isn't really familiar with this perhaps why they are lingering on the home screen and not creating a new node. So Selene quickly mutates the floating action button into a text button in the bottom that clearly states and of course this is in English but it could be in any language it clearly states a new node. So this allows that user to understand what the floating action button was for what it mutated into and in user passes another app had to do this to perhaps do it quicker. So one of the things to keep in mind is that if you have a look at Selene the floating action button the user and changing the button the next time the app is open it happens in front of the user it transforms and becomes a rectangle and it shows the user where it came from because doing it the next time the app is open we talk about user confusion and user experience how do you know that they are going to be confident about using it so doing it correctly while animating the floating action button into a rectangle rather than doing it the next time the app is opened to throw the user off the path mutating for visibility so we talked about sunlight and how an app would look under so the base of designing for lighting conditions is that in white in unbright sunlight conditions all colors move closer to white so black becomes dark gray dark blue becomes light blue but then if you move closer to white there is no place for white to move so white is the immutable color in designing for visibility so if we look at our instinct and we design according to our instinct that says the brighter the lighting the brighter we need the screen to be our instinct tells us we can make it really bright white and with black text on it it's a high contrast but that's not a good solution because white is the immutable color so you need the text to be immutable not the background so if you look at Selene and if you look at how it shows your notes it shows you a variety of colors that you could see on the palette earlier we talked about mother design but under specific lighting conditions it mutates towards the darker variant of the mother design brand color this allows a better contrast and again we're not doing it just sudden change we're doing it gradually to keep the user's confidence in mind mutating for behavior how many of us have used the protein action button? I think everyone everyone loves the fab so most of us use it even that with the primary action but do we really know with the primary action and I can have multiple use cases so let's look at this app Selene pushing aims to draw a grid on the screen and there's a variety of options like changing the color changing the type of the grid but a lot of users just enter the app, turn on the grid and leave now this is something I worked on myself so I could observe the user's pattern most of them were just entering it pressing the button and leaving because the grid stays positioned but I could not confidently move to using the protein action button as a permanent action because not all my users were doing it so mutating for user behavior would involve something like measuring the ratio that button is the first item clicked how many times did you click on another item before pressing that so if you look at this from a developer's perspective this would involve a simple checking which things pressed first by perhaps a motion down event and then checking the ratio when it's open if it's high enough because the protein action button is 98% use case if the ratio between the first touch of the switch so the other item is high enough could perhaps mutate into a protein action button what this would do is the fab is really easy to look at and really easy to click on and it's right there in the control screen the keys, that access and user's are familiar with it very common pattern mutating into that would allow them to quickly enter the app and press the button rather than reaching to the top of the screen and toggling the switch every time because the switch involves pressing it at the top corner for touch accuracy again this is something we are going to talk about from a more developer's perspective because I think after this point it's been highly theoretical let's look at a typical material design dialogue the buttons are touching each other sure they have a padding around the text but the buttons usually touch each other not only that but both the dialogue buttons are about 24 dp away from the dialogue now keeping in mind that dialogues can also be dismissed by touching outside the dialogue and considering how that will work usually don't have such a great touch accuracy like perhaps picture a little older user who can't touch on the point the first time need a few tries now that would make a big difference when there is a button on the screen because they could try again but imagine an important dialogue popping up on one of the actions but perhaps the positive action because the dismissing is completely closer to the button so they can track the positive action but the end up 24 dp is a very small space on the screen it's like perhaps less than a centimeter so even if they are less than a centimeter off they end up dismissing the dialogue rather than pressing the positive button this would margin of error is there because dialogue can be accidentally dismissed moving on this would perhaps move the buttons little up and little to the left if there is a case of the dialogue being dismissed or perhaps if they are under pressing the wrong button or pressing outside the margin of the button the button spacing could be increased now this is really efficient because this is going to end up dismissing the dialogue and they are under pressing the wrong button so just moving a little bit during the usage would improve the user experience because they press the action they want again if you are implementing this for all users it would not make sense because it is a waste of space all of us don't need large buttons and large margins only a few of us need it and we will get all the problems but dismissing for those who need it and doing it only for them let's look at another example for physical activity this is a very very developer's perspective everyone has used this view so in this view we specify a row view and then go on to that in the adapter now pick a simple app like perhaps a contact app and imagine a little elderly user using the contacts app and mistakenly pressing the wrong contact every time the typical list height that we keep in material design is around 56dp but for the for an elder user there isn't enough you can't increase it for all because there will show less amount of contacts on the screen and provide a left and optimal user experience so we mutate on that design now how can we achieve this so imagine we have the row view and within that we have three layouts it can be any layout of your choosing the typical row view 56dp and we break that down into perhaps an 8x8 and 40 ratio and set the same touch action for all three all three if the list view is meant to direct contact all three touch targets would do the same action but the app and the framework would both detect when either the extreme top or the extreme bottom touch target is pressed rather than the center of the button so ideally the app would send this to the Gaia framework which would then record that the user is not really touching very accurately and they are touching on the top or bottom targets which would perhaps feed a mutation so the first couple of times it's not going to be anything because it could be a short term behavior rather than a long term experience but over time as Gaia realizes that this is happening more and more often it would allow a mutation and there is increase to say certain machine design limits that we have introduced with me and so on rules of everyday design is one of the most important things because everyday design is like a loaded gun you can do something really bad and end up ruining the company user experience of the app this helps in aims to address most of the doubts that we talked about earlier the user is confident if you pull out the rug from under the user and have drastically trained the app experience this is not going to like the app because if they are familiar with one thing and using the app again and again and coming clicking on the same thing every time changing that suddenly result in the user being frustrated with your how implemented mutation design so doing it gradually like we talked about in Celine perhaps over time it could be something simple like surely the mother design where there was a base brand color and there was a darkest color now we could do it by saying that ok this light is above a certain threshold just use the darkest color in the palette so that would not make sense because they are going from the lightest to the darkest in one mode and not only providing a good user experience so instead what the design would suggest is that you set certain break points in the light intensity and when it reaches those it becomes a little bit darker if you do this over time and you perform mutations within the user's expectations and not perhaps exceed them and break their confidence you would not you would make the user not you wouldn't do the familiarity with the app staying within their limits and within their bounds and not pulling the rug out from under them the important thing is starter states where we talked about which is the initial mutations of the mother design these have to be firmly established like perhaps let's look at Celine again so I showed you the home screen where there is a floating action button which will take us into a rectangular button now it could also be the case that every time the user opens the app they don't instantly press the button maybe for a certain set of reasons maybe they have distracted us at the time or they are looking at some other perhaps other tabs or something so the starter states are firmly established then today the design will roll back perhaps in the next two times they end up pressing floating action button quickly which means they either learn the use of the fab or they familiarize the pattern from first the mother design can roll back and perhaps stop transforming into a rectangle and just keep it as the fab not dumbing down the interface for the user the starter states need to be firmly established but in case you need to course correct during the user usage it can simply roll back to establish the artist state so the second thing is infinite characteristics so if we we talk for a lot of things that we have to keep in mind what types of color line is multiple types of accessibility data sacrifice etc so as designers if we think that this is a certain set of things that we need to mutate for we will write back to square one because we are doing what we think is right for a certain set rather than allowing you to go on with it so in the long run this would be handled by machine learning in the short run the mutated event community is coming together to establish a wide and complete subset of all mutations that could be performed for now and the guy in the long run would leave that to machine learning so the important thing here is to not do what we think is right but rather to allow to the what the community is doing and leave it to machine learning we come in right back to square one we trust that instinct over what will happen maintaining the user's identity so if we would do an analogy on this it could be that if we are mutating a human body and so if maintaining your identity it would perhaps be increasing the length of the arms do something else would perhaps be removing the arms and going through the legs instead which would not make sense because you are losing the identity of a human body so coming back to this product's identity like you look at the mother design you could have moved from light blue to black and that would have the best readability but if you move to black you would lose the branding and the product blue color which would completely with the product's branding it would not look like saline anymore it would look like a system node sap with the black nodes so the important thing is to keep the product's identity in mind so that even if I and mine mutates to a darker color if I hand it off to someone you know it's just a dark color of the mother design not something completely different you can look at what I talked about moving to black would lose the identity of the blues but staying within the spectrum of the blue would not have that effect deciding when to mutate so one of the important things we need to keep in mind is monitoring energy usage over time and not mutating for short term behaviors another thing to keep in mind is to respect the boundaries of the platform and the product or perhaps if we set it up so that every time the user clicks on the top or bottom of the list you increase the height but if you don't cap that you perhaps end up with contacts the entire half the size of the screen so we need to keep the device's boundaries in mind another place that could be this could be looked at is suppose you're just pressing with the operator corner of the button and to fix that you perhaps move the button a little to the top and a little to the right because the touch is there but if you keep doing that the button will end up moving off the screen which is actually breaking the boundaries of the device another way this could be talked about is if we see that most of our users are coming from another platform and we perhaps mutate to base on that platform guidelines you will be breaking the boundaries of the platform itself so all these things that the boundaries of the product the platform and the device to be kept in mind while performing mutations this is also course corrected we talked about if something goes wrong and the user doesn't want to do it anymore like if the touch accuracy gets better after some time you could quickly roll back to the initial 56 dp height of the list view that we have so course correcting and rolling back for services is another important thing to do let's have a quick recap of what we talked about so we talked about user centric design and how that disregards the diversity in our population by overlooking simple things that define a user and make each of us unique it's an abstraction of a very large set because humans are very varied and combining them into one user and designing for that user doesn't make sense so mutated design aims to solve this by tailoring the design for that user itself and keeping in mind his outlook his needs and his behavior rather than for that perfect set that we formed things to keep in mind while implementing mutated design within user expectations don't pull the rug out from under the user so that would be breaking the experience and overwhelming the user taking away what they are familiar with within a set of rules respect the boundaries of the platform the device and the product identity itself because breaking those would prove disasters for all three things so links Liam Faragran has been taking the entire design community forward so three really easy links to look at the first is Syrians complete source code which you can look at and it shows you the Gaia class it shows you how it reads the light sense values and darkens the palette of brand it also shows you how it performs the animation between working action button when the animation triggers when it changes to rectangle button the second is first one is the link to the app and second is the link to the source code and the third is the link to the mutated design community where all the discussions are taking place right now and all the decisions about it are being voted on as a whole so I'll take your question interesting so my question is regarding the when you talk about from floating button to bottom bar why not to show something like tooltips so is it against the philosophy of like mutative design like we understand that reason is probably not understanding the floating button rather than animating it into a bar we can even show a tooltip that what this button can do we can understand so if you are showing the tooltip you are not going towards the user, you are bringing the user to you which defeats the purpose you don't have to make the users familiar with your patterns you have to adapt your patterns for their level of familiarity I hope that answers the question so regarding the machine learning approach also like does AB testing also falls into this or not because when you say that you sometimes you set rules for common users and then machine learning but what if also we rely on AB testing for even the basic rules and then can that be reliable and then or so again AB testing doesn't really work and breaks because even if we see a 90% success rate we are still ignoring a tenth of our users mutative design aims to every single user for providing cleared experience for the popular vote or making everyone decide on one so you design for the specific user and clear the experience according to them so my question is regarding the mutative design ecosystem for app so say I have multiple apps which follow mutative design so is it so what possibility do you think do you see like the apps can intercommunicate so just one app can decide whether the user is colorblind or if he has some nervous problems so that is the idea behind the Gaia framework so right now it exists only as a class within the Selene app and only Selene app can access it but the community is pushing to include it at a more core level so right now you either need to have inter app communication using that Gaia class it should not really be the best in terms of security so Gaia needs to solve that by being a mutative framework at a more deeper level in the system so all apps can subscribe to the framework so this would work because suppose the framework knows that this user is not familiar with newer patterns like the protein action button before he even opens your new app is installed framework tells him that don't use the protein action button there is a triangular button because this user is not familiar with newer patterns so right now it is just a class within one app because this is a relatively new movement and we are trying to expand it but hopefully in future there are more core level in the system so we have an enterprise application and it is used a lot by people who might not be very tech savvy and they have to use it in outdoor conditions so I am interested in knowing like what are the parameters with which you decide the context of the user say for instance the tech size of our app the font is very large so when I first saw it I felt like this can't be true this cannot be a production app but then I was told that people who are using it outdoors they need the size of the font to actually see otherwise they will find it very difficult to use the app so you mentioned that the machine learning approach now machine learning has to have a set of input parameters so what are the parameters to decide that this user is not tech savvy or this user has a vision problem so the machine learning approach is very far off but how we will do this something right now is we could pick up whether the user is outdoors or not because we don't really have sunlight intentionally lighting indoors so perhaps if the light sensor of the device itself is picking up a really bright light the user is outdoors this parameter could be applied to both increase the contrast of the app itself and for a larger tech size whereas for the tech savvy users I think we can look at something like we did the user doesn't use a floating action button much it means perhaps not familiar with this technology another way this could be looked at which was a big discussion in the design community sometime back was the use of the navigation draw so a lot of people didn't like the navigation draw because it used to stay hidden off the screen and users weren't familiar with it the solution that time was to open it the first two times so the user knows where it is but if you look over time and you see that the user is still not using it very frequently it would be perhaps not familiar with that pattern so you could move for a simpler approach like tabs firstly a very interesting topic the talk was very good thanks for that like this morning when I was coming I had maps on and every time you would pass an underpass the interface would change to a more contrasting color so I think that's an example of mediative design so if you look at maps when at night it becomes darker I mean it was very impressive that as I approach an underpass the colors change and as soon as I came out of the underpass it changed back to its original colors so any other examples that stand out like this that you might be able to highlight I think serine is the go-to for mediative design that seems like more like an example app right now which is very focused in live apps I talk about the keyline pushing app I talk about the grid app so that is something that's in production that's using mediative design in production any other apps from the more popular ones that you see any of those that have good examples so I can actually get back this is a really new moment which is less than a year old so we're trying to get it out to use more popular apps most people are they know about it, they're thinking about it but they're not sure whether they want to put it in production yet perhaps the moment grows bigger hopefully we'll see it coming to more popular apps but right now I think it's limited to a few apps it's more theoretical and practical also do you see it as being something of more of a concept in developing countries or in countries where people are now getting more tech-sci than they were earlier so what do you think that's a thing like maybe in developing now people with WhatsApp there's an entire demographic which earlier wasn't much into this app usage and are now getting on to it so do you think this is one of the things that applies more to them I mean definitely applies more to them because even if we see that ok India is developing more and we start using the newer patterns there's clearly a large population in India that is not familiar with the pattern but I think this is definitely one case that it needs to apply in developing markets where you design for uses for tech-sci as well as those who are not thanks you need to see the links so it's source.tv.xyz the simple link is the lean.tv.xyz source.tv.xyz and community.tv.xyz any more questions? Thank you